Chapitre 1 CPU

Unité Centrale de
Traitement
Processeur
F. Touchard Polytech Marseille INFO3 2015-16 Cours d'Architecture des ordinateurs CPU
Introduction
● on a vu comment des éléments de logique combinatoire
ou séquentielle permettaient de
➢ faire des additions, des comparaisons
➢ lire ou écrire dans des registres
➢ lire ou écrire dans de la mémoire
● on va voir maintenant comment exécuter des séquences
cohérentes d'opérations : instructions
● Cf le cours de Logiciels de Base
● approche simplifiée, basée sur l'architecture MIPS
➢ Référence : Patterson et Hennessy
F. Touchard Polytech Marseille INFO3 2015-16 Cours d'Architecture des ordinateurs CPU 2
Introduction
● étude d'un sous-ensemble des instructions du processeur
MIPS incluant :
➢ l'accès aux données mémoire en lecture (load, lw) et en
écriture (store, sw)
➢ les opérations arithmétiques et logiques add, sub, and, or,
slt
➢ l'instruction de branchement conditionnel sur égalité beq
➢ l'instruction de saut inconditionnel j
Introduction
● toutes les instructions vont d'abord
➢ aller chercher dans la mémoire du programme l'instruction
qui correspond au contenu du registre de programme
(Program Counter)
➢ décoder l'instruction et lire un ou deux registres indiqués
dans les champs de l'instruction (rs, rt)
● ensuite ça va dépendre de la classe de l'instruction, mais
les comportements sont souvent les mêmes
➢ utilisation de l'ALU
✔ arithmétique, logique
✔ calcul d'adresse
➢ accès mémoire et/ou aux registres
Introduction
● représentation schématique
Introduction
●Le PC peut recevoir l'adresse

par une simple incrémentation
Introduction
●Le PC peut recevoir l'adresse

par une simple incrémentation ou
par une instruction (saut)
Introduction
● Les données écrites dans les

registres peuvent venir de l'ALU
Introduction
● Les données écrites dans les

registres peuvent venir de l'ALU
ou de la mémoire
Introduction
➢ l'origine des instructions comme celle des données est
multiple
➢ on ne peut pas connecter simplement des lignes électriques
différentes
Introduction
●Pour choisir le bon chemin, on va

utiliser des multiplexeurs
Introduction
Introduction
●utilisation de
3 multiplexeurs
pour choisir l'origine des
données
Introduction
● une unité de contrôle utilisant

l'instruction permet de gérer le
fonctionnement des circuits et
des multiplexeurs
Introduction
● l'incrémentation du PC est gérée

par la sortie de l'ALU utilisée pour
effectuer la comparaison pour
l'instruction beq
plan du cours
● réalisation d'une ALU effectuant les opérations de base
arithmétiques et logiques
● CPU en mode cycle unique
➢ réalisation d'un chemin de données
➢ réalisation une unité de contrôle
● CPU en mode multicycle
➢ chemin de données
➢ contrôle
➢ gestion des interruptions
● CPU en mode pipeline
➢ contrôle
➢ gestion des aléas
● Hiérarchie des mémoires. Caches
plan du cours
➢ contrôle
➢ contrôle
Implémentation d'une ALU
● réalisation des opérations
➢ arithmétiques : addition et soustraction
➢ logiques : ET et OU
● on a vu comment réaliser un additionneur en logique
combinatoire
➢ on le considère maintenant comme une boîte noire
CarryIn
+ Result
b
CarryOut
● ALU 1 bit
➢ addition
➢ opérations logiques ET, OU
Combien de
bits pour coder
Op Op ?
CarryIn
a 0
1 Result
+ 2
b
CarryOut
● réalisation d'une ALU 32 bits
Op
le CarryIn du
bit le moins
significatif est a0 CarryIn
forcé à 0 ALU0 Résultat0
b0 CarryOut
a1 CarryIn
ALU1 Résultat1
b1 CarryOut
a31 CarryIn
le CarryIn du ALU31 Résultat31
bit le plus b31 CarryOut
significatif est
perdu
● pour effectuer la soustraction
➢ a−b=a+ b̄ +1
CarryIn du bit le moins
significatif forcé à 1
pour la soustraction
b Invert
CarryIn Op
a 0
1 Result
b 0 + 2
1
CarryOut
● pour effectuer les autres opérations logiques
➢ utilisation du théorème de De Morgan
➢ NOR : a+b=a.b
➢ NAND : a.b=a+b
b Invert CarryIn Op
a Invert
a 0
1 0
1 Result
b 0 + 2
1
CarryOut
● notre ALU effectue les opérations arithmétiques et
logiques de base
● on voudrait qu'elle puisse exécuter l'instruction slt
(set on less than)
➢ le résultat vaut 1 si rs < rt
➢ sinon 0
● met les 31 bits de poids fort à 0 et le bit le moins
significatif à 0 ou 1 suivant le résultat de la comparaison
● une opération supplémentaire pour le multiplexeur : Less
● nouvelle version de l'ALU 1 bit :
a invert
binvert CarryIn
Op
a 0
1 0
b 0 + 2 Result
1
Less 3
CarryOut
● nouvelle version de l'ALU 32 bits :
➢ pour les 31 bits de poids fort, on connecte l'entrée Less à 0
et ce sera la sortie de l'ALU 1 bit correspondante (ALU31 à
ALU1)
➢ le bit le moins significatif (ALU0) doit être à 1 si a<b.
✔ c'est la valeur du bit de signe du résultat de a-b
✔ le bit de signe du résultat de a-b est le bit de poids le plus fort
de l'additionneur (qui n'est pas la sortie de l'ALU31)
➢ nécessité d'une ALU31 spécifique pour le bit de poids le plus
fort avec une sortie spéciale (Set) donnant le bit de signe (bit
de sortie de l'additioneur) et utilisée uniquement pour
l'opération slt
● ALU 31 :
a Invert b Invert CarryIn
Op
a 0
1 0
b 0 + 2 Result
1
Less 3
Set
CarryOut
● ALU 31 : il faut aussi détecter les dépassements de
capacité b a Invert Invert
CarryIn
Op
a 0
1 0
b 0 + 2 Result
1
Less 3
Set
Cf TD Détection du
dépassement Overflow
de capacité
ainvert binvert CarryIn Operation
● ALU 32 bits
v
a0 CarryIn Résultat0
b0 ALU0
Less
CarryOut
b1 ALU1
0 Less
CarryOut
b2 ALU2
0 Less
CarryOut

b31 ALU31
0 Less Set
Overflow
● si l'on veut aussi effectuer des branchements
conditionnels, il faut pouvoir effectuer des tests de
comparaison sur le contenu de 2 registres
➢ on va tester si a-b vaut 0
✔ si oui a=b
✔ si non a≠b
➢ la façon la plus simple de tester l'égalité est
Zero = Résultat31+Résultat30+...+Résultat1+Résultat0
● ALU 32 bits
b0 ALU0
Less
CarryOut
b1 ALU1
0 Less Zero
CarryOut
b2 ALU2
0 Less
CarryOut

b31 ALU31
0 Less Set
Overflow
● ALU 32 bits
v
b0 ALU0
Less
CarryOut
b1 ALU1
0 Less Zero
CarryOut
b2 ALU2
0 Less
CarryOut

b31 ALU31
0 Less Set
Overflow
● Représentation symbolique
ALU operation
4
32
a
Zero
32
Result
Overflow
32
b
CarryOut
plan du cours
➢ contrôle
➢ contrôle
Réalisation d'un chemin de données
● les éléments du processeur qui permettent d'exécuter une
opération arithmétique ou logique
● la liste des éléments nécessaires va dépendre du type de
l'instruction
● rappel :
➢ toutes les instructions vont d'abord
✔ aller chercher dans la mémoire du programme l'instruction qui
correspond au contenu du registre de programme (Program
Counter) : Instruction fetch (IF)
✔ décoder l'instruction et lire un ou deux registres indiqués dans
les champs de l'instruction (rs, rt) : Instruction decode (ID)
➢ ensuite ça va dépendre de la classe de l'instruction, mais
les comportements sont souvent les mêmes
✔ utilisation de l'ALU : Execute (EX)
✘ arithmétique, logique
✘ calcul d'adresse
✔ accès mémoire : Memory Access (Mem)
✔ accès aux registres : Write back (WB)
● pour réaliser un chemin de données,
on a besoin
➢ d'un registre pour stocker
PC
l'adresse de l'instruction
➢ d'une mémoire pour stocker adresse de

l'instruction
les instructions à des adresses instruction
données Mémoire des
instructions
➢ d'un additionneur pour calculer
l'adresse de l'instruction suivante
Add
● ensuite on peut assembler les éléments pour obtenir une
partie du chemin de données allant chercher une
instruction et incrémentant le compteur de programme
pour obtenir l'adresse de l'instruction suivante
Add
PC adresse de
l'instruction
instruction
Mémoire des
instructions
● instructions de type R (MIPS)
lisent le contenu de 2 registres
➢
➢ effectuent une opération arithmétique ou logique
➢ écrivent le résultat dans un registre
➢ add, sub, and, or, slt
add $t0,$t1,$t2 place la somme de $t1 et $t2 dans $t0

● les 32 registres de travail de l'architecture MIPS sont
regroupés dans une structure appelée register file
➢ chaque registre a une utilisation spécifique
✔ registres pour les variables : $s0, $s1, ...
✔ registres pour les données temporaires : $t0, $t1, ...
✔ stack pointer : $sp, zéro : $zero, registre d'adresse de retour :
$ra
➢ les registres sont identifiés par leur numéro (cf cours LdB)
✔ $zero → 0
✔ $t0 → $t7 : 8 →15
✔ $s0 → $s7 : 16 →23
● éléments nécessaires pour implémenter une instruction
de type R :
Code opération
5 Registre
4 ?
lecture #1 Données
lecture #1
5 Registre Zéro
numéro des lecture #2
registres Données
Registres en sortie ALU
Résultat
5 Registre ALU
écriture Données
lecture #2
Données
Données écriture
en entrée
Ecriture
TD registre
● instructions d'accès aux mots
➢ lw $t1, offset_value($t2)
➢ sw $t1, offset_value($t2)
➢ lw : lu de la mémoire et chargé dans le registre $t1
✔ → mémoire
➢ calcul de l'adresse en ajoutant offset_value à l'adresse
de base stockée dans $t2
✔ → ALU
➢ offset_value est un entier signé de 16 bits
→ il va falloir l'étendre à 32 bits en recopiant le bit de signe
de l'entier 16 bits dans les bits de poids forts de l'entier 32
bits
→ module dédié
● modules nécessaires :
➢ les éléments déjà vus
✔ register file
✔ ALU pour incrémenter le PC
➢ une unité mémoire dans laquelle on va lire ou écrire les
données
➢ module pour l'extension de l'offset de 16 bits non signés à
32 bits sigés
Contrôle
écriture mémoire
adresse
données en
lecture 16 Extension 32
Mémoire du bit
données de signe
de l'offset
données en
écriture
Contrôle
lecture mémoire
● instructions de branchement
➢ beq $t1, $t2, offset
➢ 3 opérandes
✔ 2 registres dont les contenus vont être comparés
✔ un offset pour calculer la nouvelle adresse de l'instruction à
exécuter en cas d'égalité des registres
✘ l'adresse de base est celle de l'instruction qui suit beq
(déjà calculé quand on va chercher l'intruction en cours)
✘ l'offset est basé sur le "mot" de 4 octets : on peut le
décaler à gauche de 2 bits de façon à augmenter l'échelle
d'un facteur 4)
● instructions de branchement
➢ beq $t1, $t2, offset
➢ 3 opérandes
✔ on prend le branchement si les contenus des registres sont
égaux : l'adresse de la prochaine instruction est le nouveau
contenu du PC + l'offset
✔ sinon le branchement n'est pas pris et l'adresse de la
prochaine instruction est simplement le nouveau contenu du
PC
PC+4
(venant du chemin de données) ALU
Somme Adresse de
branchement
Décalage
à gauche
de 2
Registre
lecture #1 code
4 opération
Instruction
Registre Données ALU
lecture #2 lecture #1
Logique de
Registres Zéro
contrôle
Données
Registre
lecture #2
écriture
Données
écriture
Ecriture
registre
16 Extension 32
du bit
de signe
● on vient de voir comment réaliser les composants d'un
chemin de données pour différents types d'instructions
● on va voir maintenant comment assembler ces éléments
pour réaliser un chemin de données unique capable
d'exécuter toutes les instructions
● cas le plus simple où chaque instruction est exécutée en
un seul cycle de l'horloge
➢ chaque ressource ne peut être utilisée qu'une fois par
instruction  duplication des ressources
➢ sources de données multiples et utilisation de multiplexeurs
gérés par des signaux de contrôle
● Exemple : exécution des instructions de type R et de
recherche en mémoire
➢ les chemins de données pour les deux types d'opérations
sont assez semblables, mais :
✔ les opérations de type R
✘ utilisent l'ALU avec des entrées provenant de 2 registres
✘ stockent le résultat de l'ALU dans un registre du register file
✔ les opérations d'accès à la mémoire
✘ utilisent l'ALU pour le calcul de l'adresse avec pour second
opérande la valeur d'offset provenant directement de
l'instruction
✘ stockent le contenu de la mémoire dans le register file
● Exemple : exécution des instructions de type R et de
recherche en mémoire
code
opération
4 Ecriture
Registre Données mémoire
Instruction lecture #1 lecture #1 Mémoire
Zéro
vers
Registre ALU registre
lecture #2 Résultat Adresse
Source
Registres ALU Données
Données lues 1
Registre lecture #2
0
Mémoire M
écriture M u
Données u données
écriture x
x 0
1
Ecriture Données
registre à écrire
16 Extension 32 Lecture
du bit mémoire
de signe
● pour toutes les opérations envisagées, on va combiner
les chemins de données vus pour
➢ les opérations de type R
➢ les opérations d'accès à la mémoire
➢ les branchements
0
M
Add Add u
x
4 Résultat
Décal. 1
gauche
2 bits Source
PC
Registre
lecture #1 Ecriture
Données Mémoire
lecture #1 mémoire vers
Registre registre
lecture #2 Zéro
Lecture Source
adresse ALU ALU
Registres Adresse 1
0 Résultat
PC 0 Données
M
instruction M Registre Données lues
(31:0) écriture lecture #2 M u
u
Données u Mémoire x
x 0
écriture x données
Mém. 1 Contrôle
1 ALU
instr.
Données
Destination à écrire
registre Ecriture
registre
Lecture
mémoire
Ext. 32
bit de
signe
plan du cours
➢ contrôle
➢ contrôle
Implémentation d'une unité de contrôle
● prend le contenu des instructions pour gérer les signaux
d'écriture, la sélection sur les multiplexeurs, le contrôle de
l'ALU
● première approche simplifiée couvrant les instructions
➢ lw, sw
➢ beq
➢ add, sub, and, or, set on less than
● Contrôle de l'ALU
● 4 bits pour le contrôle
➢ seulement 6 opérations pour notre implémentation
a invert binvert (+CarryIn) Lignes de contrôle

Op de l'ALU Fonction
a inv b inv Op 1 Op 0
a 0
1 0 AND
OR
1
add
b 0 + 2 Result
1 sub
Less 3 set on less than
NOR
CarryOut

a 0
1 0 0000 AND
OR
1
add
b 0 + 2 Result
1 sub
Less 3 set on less than
NOR
CarryOut

a 0
1 0 0000 AND
0001 OR
1
0010 add
b 0 + 2 Result
1 0110 sub
Less 3 0111 set on less than
1100 NOR
CarryOut
● Contrôle de la CPU « cycle unique »
● rappel : format des instructions MIPS pour les instructions
de type R, de branchement et d'accès à la mémoire
champ 0 rs rt rd shamt funct
position des bits 31:26 25:21 20:16 15:11 10:6 5:0
instructions de type R (exemple : add rd, rs, rt )
champ 3510 ou 4310 rs rt offset

position des bits 31:26 25:21 20:16 0:15
instructions d'accès à la mémoire (exemple : lw rt, offset(rs) )
champ 410 rs rt offset

instructions de saut conditionnel (exemple : beq rs, rt, offset)
● remarques :
➢ le champ d'opération (opcode) est toujours contenu dans
les bits [31:26] : Op[5:0]
➢ les registres à lire sont toujours spécifiés par les champs
rs [25:21] et rt [20:16]
➢ le registre de base pour les opérations d'accès en mémoire
est donné par le champ rs [25:21]
➢ l'offset pour les branchements et les accès mémoire est
toujours contenu dans les bits [15:0]
➢ le registre de destination est soit
✔ dans rt [20:16] pour un lw
✔ dans rd [15:11] pour les instructions de type R
 nécessité d'un multiplexeur supplémentaire
● les entrées de contrôle pour l'ALU vont pouvoir être
générées par
➢ le champ de fonction de l'instruction (bits 0 à 5 pour les
instructions de type R, cf cours LdB)
➢ un champ de 2 bits nommé ALUOp qui vaut
✔ 00 pour les add liées aux instructions lw et sw
✔ 01 pour les sub liées aux instruction beq
✔ 10 pour les instructions dont l'identité est définie par le champ
de fonction
● bits de contrôle de l'ALU
Entrées de
Code Champ de contrôle de
ALUOp Opération Action de l'ALU l'ALU
opérationnel fonction
LW 00 load word XXXXXX add 0010

SW 00 store word XXXXXX add 0010
Branch equal 01 branch equal XXXXXX substract 0110
R type 10 add 100000 add 0010
R type 10 substract 100010 substract 0110
R type 10 AND 100100 and 0000
R type 10 OR 100101 or 0001
R type 10 set on less than 101010 set on less than 0111
➢ utilise le champ de fonction et un champ de contrôle de 2

bits
➢ on va maintenant relier les champs de l'instruction au
chemin de données
● table de vérité (limitée aux opérations qui requièrent un
code opérationnel pour l'ALU)
ALUOp Champ de fonction

Opération
ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 Op 3 Op 2 Op 1 Op 0
0 0 X X X X X X 0010
0 1 X X X X X X 0110
1 0 1 0 0 0 0 0 0010
1 0 1 0 0 0 1 0 0110
1 0 1 0 0 1 0 0 0000
1 0 1 0 0 1 0 1 0001
1 0 1 0 1 0 1 0 0111
11 jamais utilisé toujours 10
● table de vérité (limitée aux opérations qui requièrent un
code opérationnel pour l'ALU)
ALUOp Champ de fonction

Opération
ALUOp1 ALUOp0 F5 F4 F3 F2 F1 F0 Op 3 Op 2 Op 1 Op 0
0 0 X X X X X X 0010
X 1 X X X X X X 0110
1 X X X 0 0 0 0 0010
1 X X X 0 0 1 0 0110
1 X X X 0 1 0 0 0000
1 X X X 0 1 0 1 0001
1 X X X 1 0 1 0 0111
implémentation
en TD
0
M
Add Add u
x
4 Résultat
Décal. 1
gauche
2 bits Source
PC
instruction [25:21]
Registre
lecture #1 Ecriture
Données Mémoire
instruction [20:16] Registre registre
lecture #2 Zéro
Lecture Source
adresse ALU ALU
Registres Adresse 1
0 Résultat
PC 0 Données
M
u
x 0
Mém. instruction 1
1
instr. [15:11] Données
registre Ecriture
registre
Lecture
mémoire
Ext. 32 Contrôle
instruction [15:0] ALU
bit de
signe
2
instruction [5:0] ALUOp
0
M
Add Add u
x
4 Résultat
Décal. 1
gauche
2 bits Source
PC
instruction [25:21]
Registre
lecture #1 Ecriture
Données Mémoire
instruction [20:16] Registre registre
lecture #2 Zéro
Lecture Source
adresse ALU ALU
Registres Adresse 1
0 Résultat
PC 0 Données
M
u
x 0
Mém. instruction 1
1
registre Ecriture
registre
Lecture
mémoire
Ext. 32 Contrôle
instruction [15:0] ALU
bit de
signe
2
Lignes de contrôle
instruction [5:0] ALUOp
● effet des lignes de contrôle
Nom du signal Effet quand à 0 Effet quand à 1
Destination Registre le numéro du registre de le numéro du registre de
(RegDst) destination pour l'écriture du destination pour l'écriture du
registre Write vient du champ registre Write vient du champ rd
rt [20:16] [15:11]
Ecriture registre rien les données présentes sur
(RegWrite) l'entrée Données écriture sont
écrites dans le registre Write
Source ALU le 2nd opérande de l'ALU vient le 2nd opérand de l'ALU vient du
(ALUSrc) du 2nd registre en sortie champ [15:0] de l'instruction
(étendu à 32 bits)
Source PC la nouvelle valeur du PC est la nouvelle valeur du PC est
(PCSrc) PC+4 calculée à partir de l'offset (bits
[15:0] de l'instruction)
Lecture mémoire rien le contenu de la mémoire à
(MemRead) l'adresse indiquée en entrée est
mis sur la sortie
Ecriture mémoire rien les données sur l'entrée sont
MemWrite écrites à l'adresse indiquée
Mémoire vers registre la valeur donnée au registre la valeur donnée au registre
(MemtoReg) Write vient de l'ALU Write vient de la mémoire
données
0
M
Add RegDest Add u
Branch
MemRead x
4 MemWrite Résultat
ALUOp Décal. 1
Contrôle MemtoReg
instruction [31:26] gauche Source
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
adresse lecture #2 ALU
Adresse 1
PC 0 Registres Résultat Données
0 M
instruction M lues
(31:0) Registre Données M u
u écriture lecture #2 u Mémoire x
x 0
Données x données
Mém. instruction 1 écriture
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
add $t1,$t2,$t3 instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
PC instruction [25:21]
chargé Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
PC incrémenté
de 4
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
$t3 $t2 $t2 et $t3

instruction [25:21]
chargés dans
Registre
lecture #1 Données
l'ALU
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
l'ALU fait
l'addition
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrirerésultat chargé
dans $t1
$t1 Contrôle
Ext.
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
pas d'accès mémoire
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
lw $t1,offset($t2) instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
chargé Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
PC incrémenté
de 4
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
$t2 lu et chargé
$t2 dans l'ALU
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
offset étendu à 32 bits et

lw $t1,offset($t2) instruction [5:0] chargé dans l'ALU
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
offset + $t2 est

l'adresse mémoire
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
instr. [15:11] Données mémoire lue
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
$t1 le contenu est

instruction [25:21]
Registre stocké dans $t1
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
chargé Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
beq $t1,$t2,offset instruction [5:0]
PC incrémenté
de 4
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
calcul de l'adresse
en cas de
0 branchement
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
$t1 et $t2
chargés
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
soustraction de
$t1 et $t2
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Lecture Registre Zéro la source du
lecture #2 ALU
adresse
Registres Résultat
PC dépend du1
Adresse
PC 0 Données
instruction M
0 zéro du M
lues
M u
(31:0) u Registre Données
écriture lecture #2 u Mémoire
résultat x
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
pas d'accès mémoire

instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1
Registre Zéro
Lecture
Adresse 1
0 M
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
j address instruction [5:0]
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
en TD :
instruction [20:16]
Registre
lecture #1 Données
Registre
lecture #1
jump Zéro
Lecture
PC
adresse
0
lecture #2
Registres + 0
ALU
Résultat
Adresse
Données
1
M
combinatoire
instruction M lues
x 0
Données x données
1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
j address instruction [5:0]
plan du cours
➢ contrôle
➢ contrôle
implémentation multicycle
● l'exécution d'une instruction par l'unité de traitement que
l'on vient de décrire demande un seul cycle d'horloge
● l'exécution d'opérations plus complexes (par exemple une
multiplication) demanderait un chemin de données et un
contrôle beaucoup plus complexes
● la fréquence de l'horloge doit être adaptée à l'instruction
la plus longue (qui n'est pas généralement la plus
fréquemment utilisée)
● pour optimiser la vitesse de la CPU, on peut décomposer
des opérations plus complexes en une série d'opérations
élémentaires
● une autre possibilité est la technique du « pipelining »
● le chemin de données devra avoir une organisation
différente et posséder des registres supplémentaires pour
stocker des résultats intermédiaires
Instruction
register Data
PC Address
A
Instruction Register #
or data Registers ALU ALUOut
Memory Register #
Memory B
Data data Register #
register
stocker des résultats intermédiaires
une seule ALU (au
lieu d'une ALU et
de 2 additionneurs
Instruction
register Data
PC Address
A
Memory Register #
Memory B
register
une seule unité de
stocker des résultats
mémoire pour intermédiaires
les
instructions et les
données
Instruction
register Data
PC Address
A
Memory Register #
Memory B
register
stocker des résultats intermédiaires plusieurs registres
de stockage
intermédiaire
Instruction
register Data
PC Address
A
Memory Register #
Memory B
register
registre
● nécessité de multiplexeurs supplémentaires données A ou
PC
une seule
mémoire 0
M
une seule ALU
Instruction u
[25-21] Registre
0 lecture #1 Données
x
PC adresse
M Instruction lecture #1 A 1
[20-16] Registre zéro
u 0 lecture #2
x Mémoire M ALU
Registres résultat ALUOut
1 Instruction u
données
[15-0] [15-11] x Registre Données B 0
1 écriture lecture #2
Registre Données 4 1 M
écriture
instructions écriture u
2
0 x
choix de M
3
l'origine de u
x
l'adresse registre données B
1
Registre ou offset ou
données
Ext. Décal. incrémentation du
mémoire 16 32
bit de gauche PC de 4 ou offset
signe 2 bits
PCWriteCond PCSource
PCWrite Outputs ALUOp

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction [25-0] left 2 2x
Instruction
[31-26]
PC 0 PC [31-28]
M Instruction Read 0
u Address [25-21] register 1 Read M
A u
1x Memory Instruction Read
data 1
Zero
[20-16] register 2 1x
MemData 0 Registers ALU
Instruction M ALU ALUOut
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
register extend left 2 Control
Instruction [5-0]
plan du cours
➢ contrôle
➢ contrôle
● découpage de chaque instructions en une série de pas
➢ un pas est exécuté à chaque top de l'horloge
➢ un pas peut être constitué de plusieurs opérations
exécutées en parallèle
➢ à l’intérieur d’un pas, certaines opérations pourront se
révéler inutiles, mais cela n’aura pas rallongé le temps
d’exécution
● en général
➢ aller chercher l'instruction
➢ décoder l'instruction
➢ exécuter l'instruction
➢ terminer l'exécution de l'instruction

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
1. aller chercher l'instruction

0 IorD ALUSrcB
1 MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
1 Jump
1M
address
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
IR <= Memory[PC] Memory 16
Sign
32
ALU
data Shift
Instruction [5-0]

0 IorD ALUSrcB
1 MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
1 Jump
1M
address
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
u
dérivé du langageMemory
Verilog pour
1x :
Instruction
[20-16]
Read
data 1 A
1x Zero
register 2
charger dans le MemData
registre IR le
Instruction
0 Registers ALU
ALUOut
M ALU
contenu de laWrite
mémoire à [15-0] Instruction u
Write
register Read result
[15-11] data 2 B 0
l'adressedata
« PC » Instruction
register
1x
4 1M
Write
0 data 2u
Instruction M 3x
[15-0] u
1x
IR <= Memory[PC] Memory 16
Sign
32
ALU
data Shift
Instruction [5-0]
PCWrite Outputs ALUOp 00

0 IorD ALUSrcB
1 Control
01
MemRead
MemWrite
ALUSrcA 0
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
1 Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0010
Instruction M 3x
[15-0] u
1x
IR <= Memory[PC] Memory
data
16
Sign
32
Shift ALU
PC <= PC+4 register extend left 2 Control
Instruction [5-0]

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
2. décoder l'instruction
A <= Reg[IR[25:21]]

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
A <= Reg[IR[25:21]]
B <= Reg[IR[20:16]] PCWriteCond PCSource

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
A <= Reg[IR[25:21]]
AluOut <= PC+(sign-extend[IR[15:0]>>2)

IorD ALUSrcB
MemRead Control 11
MemWrite
ALUSrcA 0
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0010
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
3. exécution, calcul d'une adresse mémoire ou branchement

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
3. exécution, calcul d'une adresse mémoire ou branchement

IorD
va dépendre de la classe MemRead
de l'instruction
Control
ALUSrcB
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
accès mémoire

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
accès mémoire AluOut <= A+sign-extend(IR[15:0]

IorD ALUSrcB
MemRead Control 10
MemWrite
ALUSrcA 1
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0010
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
instructions de type R

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
instructions de type R

ALUOut <= A op B IorD ALUSrcB
MemRead Control 00
MemWrite
ALUSrcA 1
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x xxxx
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
branchements register extend left 2 Control
Instruction [5-0]
PCSource
Zero 1 PCWriteCond 01
IorD ALUSrcB
MemRead Control 00
MemWrite
ALUSrcA 1
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0110
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
branchements register extend left 2 Control
Instruction [5-0]
if (A==B) PC <= ALUOut
1 PCWrite Outputs ALUOp

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
sauts non conditionnels
PCSource
PCWriteCond 10
1 PCWrite Outputs ALUOp
IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
PC <= {PC[31:28], (IR[25:0], 2'b00)}
Instruction [5-0]
sauts non conditionnels

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
4. terminaison d'un accès mémoire ou d'une instruction de type R

accès mémoire load

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
accès mémoire load MDR <= Memory[ALUOut]

1 IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
accès mémoire store

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
accès mémoire store Memory[ALUOut] <= B

1 IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
instruction de type R

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
instruction de type R Reg[IR[15:11]] <= ALUOut

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
0
Op
IRWrite RegDest
[5-0] 1 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
5. terminaison d'un accès mémoire load

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
5. terminaison d'un accès mémoire load Reg[IR[20:16]] <= MDR

IorD ALUSrcB
MemRead Control
ALUSrcA
MemWrite
1 MemtoReg RegWrite
Op
IRWrite [5-0] 0 RegDest 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
● spécification du contrôle à l'aide de machines à états finis
➢ un ensemble d'états
➢ des directions pour passer d'un état à un autre
➢ tout contrôle non spécifié est réputé à 0 (faux)
départ
● chargement de l'instruction
● décodage
● instructions ● instructions ● instructions ● instructions

d'accès de type R de branchements de sauts non
mémoire conditionnels conditionnels
● chargement et décodage
chargement
décodage
0 1
W '
= 'S eR
Q'
p
BE
O p ty
Op = 'J'
ou =
='
W' p
' L O
Op
=
Op
machine machine machine machine

accès mémoire type R branchements sauts
implémentation multicycle (rappel)

0 IorD ALUSrcB
1 Control
01
MemRead
MemWrite
ALUSrcA 0
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
1 Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0010
Instruction M 3x
[15-0] u
1x
IR <= Memory[PC] Memory
data
16
Sign
32
Shift ALU
PC <= PC+4 register extend left 2 Control
Instruction [5-0]
chargement
décodage
0 MemRead 1
ALUSrcA = 0
IorD= 0
IRWrite
ALUSrcB = 01
ALUOp= 00
PCWrite
PCSource = 00
W '
= 'S eR
Q'
p
BE
O p ty
Op = 'J'
ou =
='
W' p
' L O
Op
=
Op

implémentation multicycle (rappel)
A <= Reg[IR[25:21]]
AluOut <= PC+(sign-extend[IR[15:0]>>2)

IorD ALUSrcB
MemRead Control 11
MemWrite
ALUSrcA 0
MemtoReg RegWrite
Op
IRWrite RegDest
[5-0] 0
Jump
address 1M
26 Shift 28 [31-0] u
Instruction
[31-26]
PC 0 PC [31-28]
A u
data 1
Zero
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
0010
Instruction M 3x
[15-0] u
1x
Memory 16 32
data Sign Shift ALU
Instruction [5-0]
chargement
décodage
0 MemRead 1
ALUSrcA = 0
IorD= 0
ALUSrcA = 0
IRWrite
ALUSrcB =11
ALUSrcB = 01
ALUOp = 00
ALUOp= 00
PCWrite
PCSource = 00
W '
= 'S eR
Q'
p
BE
O p ty
Op = 'J'
ou =
='
W' p
' L O
Op
=
Op

● accès mémoire
depuis 1 (Op='LW') ou (Op='SW')
2
calcul de l'adresse mémoire
ALUSrcA = 1
ALUSrcB = 10
ALUOp = 00
(Op='SW')
(Op='LW')
5
accès mémoire accès mémoire
3
MemRead MemWrite
IorD = 1 IorD = 1
fin de la lecture mémoire

4
RegWrite retour vers l'état 0
MemtoReg = 1
RegDst = 0
● instructions de type R
depuis 1 (Op='type R')
exécution
6
ALUSrcA = 1
ALUSrcB = 00
ALUOp = 10
7 fin de l'opération
RegDst = 1
RegWrite
MemtoReg = 0
retour vers l'état 0
● Branchements conditionnels
depuis 1 (Op='BEQ')
exécution
8 ALUSrcA = 1
ALUSrcB = 00
ALUOp = 01
PCWriteCond
PCSource=01
● Sauts inconditionnels
depuis 1 (Op='J')
exécution
9
PCWrite
PCSource=10
chargement décodage
MemRead
0 1
ALUSrcA = 0
IorD= 0 ALUSrcA = 0
IRWrite ALUSrcB =11
ALUSrcB = 01 ALUOp = 00
ALUOp= 00
PCWrite
PCSource = 00
(O
')
p
)
eR
=
SW
(Op
='
'J '
)
typ
p
uO
=
o
p=
'
'BEQ
' LW
(O
p=
')
(O
calcul de
l'adresse mémoire exécution
6 exécution exécution
8 9
2
ALUSrcA = 1
ALUSrcA = 1 ALUSrcA = 1 ALUSrcB = 00 PCWrite
ALUSrcB = 10 ALUSrcB = 00 ALUOp = 01 PCSource=10
ALUOp = 00 ALUOp = 10 PCWriteCond
PCSource=01
(Op='SW')
(Op='LW') accès fin de
accès l'opération
mémoire mémoire
3 5 7
RegDst = 1
MemRead MemWrite
RegWrite
IorD = 1 IorD = 1
MemtoReg = 0
fin de la
lecture
mémoire
4
RegWrite
MemtoReg = 1
RegDst = 0
● le contrôleur de la machine à états finis est implémenté
dans un bloc de logique combinatoire
Logique
combinatoire
de contrôle sorties de contrôle du
chemin de données
sorties ...
entrées
TD
registre
entrées en d'état
provenance
du champ de
contrôle
de l'instruction
plan du cours
➢ contrôle
➢ contrôle
gestion des exceptions
● exception : tout changement inattendu dans le cours de
l'exécution de la séquence d'instructions
● une interruption est une exception provenant d'un élément
extérieur (périphérique)
➢ NB: dans le cas des architectures IA32 de Intel, toutes les
exceptions sont appelées interruptions
● peuvent être provoquées par
➢ la requête d'un dispositif d'entrée/sortie
➢ un dépassement de capacité arithmétique
➢ une instruction non définie
➢ un appel aux fonctions du système d'exploitation
➢ etc...
● dans ce qui suit, gestion
➢ des dépassements de capacité
➢ des instructions non définies
● actions de base :
➢ sauver l'adresse de l'instruction ayant causé l'exception
dans un registre dédié : EPC (Exception Program Counter)
➢ transférer le contrôle à une adresse spécifiée du système
d'exploitation en précisant la raison de l'exception
● ensuite
➢ terminer le programme
➢ ou reprendre l'exécution au point où on en était au moment
de l'occurrence de l'exception
● 2 méthodes pour le transfert de contrôle :
➢ une seule adresse de transfert et la cause est sauvegardée
dans un registre d'état (Cause Register)
➢ vecteur d'interruption : la cause de l'exception détermine le
choix de l'adresse de transfert
● l'architecture MIPS suit la première méthode
➢ 2 registres supplémentaires
✔ EPC
✔ Cause
✘ stocke la cause dans un mot de 32 bits
✘ instruction indéfinie : lsb → 0
✘ dépassement de capacité arithmétique : lsb → 1
➢ lignes de contrôles supplémentaires
✔ EPCWrite
✔ CauseWrite
✔ ligne pour mettre à 0 ou 1 le lsb de Cause
➢ adresse du point d'entrée du traitement : 0x8000 0180
➢ PC décrémenté de 4 avant stockage dans EPC
CauseWrite
IntCause
PCWriteCond
EPCWrite
PCWrite Outputs
PCSource
IorD ALUOp
MemRead Control
ALUSrcB
MemWrite
ALUSrcA
MemtoReg
RegWrite
IRWrite RegDest 0
Jump
Op [5-0] address 1M
26 Shift 28 [31-0] u
Instruction 8000 0180
3
[31-26]
PC 0 PC [31-28]
A u
data 1
Overflow
[20-16] register 2 1x Zero
Instruction M ALU ALUOut EPC
[15-0] Write result
Instruction u Read
Write register
[15-11] data 2 B 0
data Instruction 1x
register Write
4 1M
0 data 2u
Instruction M 3x 0 0
[15-0] u M
1x Cause u
Cause
Memory 1 1x
16 32
data Sign Shift ALU
Instruction [5-0]
chargement décodage
0 MemRead 1
ALUSrcA = 0 ALUSrcA = 0
IorD= 0 ALUSrcB =11
ALUSrcB = 01 ALUOp = 00
ALUOp= 00
PCWrite
PCSource = 00 (O
p=
'o
(O
') t he
' SW
p=
r')
)
eR
(Op = 'BEQ')
=
Op
'J')
typ
!
u
'o
'LW
p=
=
problème
(O
( Op
calcul de potentiel
l'adresse mémoire exécution exécution d'écriture d'un
6 8 exécution
9
2 ALUSrcA = 1 résultat faux !
ALUSrcA = 1 ALUSrcA = 1 ALUSrcB = 00
PCWrite
ALUSrcB = 10 ALUSrcB = 00 ALUOp = 01
PCSource=10
ALUOp = 00 ALUOp = 10 PCWriteCond
PCSource=01 documenté dans
(Op='SW') l’instruction set MIPS
(Op='LW') accès fin de
accès l'opération
mémoire mémoire
3 6 7
10 11
ALUSrcA = 1 RegDst = 1 O IntCause = 1 IntCause = 0
MemRead ver
flow
ALUSrcB = 10 RegWrite CauseWrite CauseWrite
IorD = 1
ALUOp = 00 MemtoReg = 0 ALUSrcA = 0 ALUSrcA = 0
ALUSrcB = 01 ALUSrcB = 01
ALUOp = 01 ALUOp = 01
fin de la EPCWrite EPCWrite
lecture PCWrite PCWrite
PCSource = 11 PCSource = 11
mémoire
4
RegWrite
MemtoReg = 1
RegDst = 0
plan du cours
➢ contrôle
➢ contrôle
pipelining
● l'approche « multicycle » améliore le temps d'exécution,
mais une grande partie du chemin de données reste
sous-utilisée pendant l'exécution des différents cycles
constituant l'instruction
● une autre approche utilise un chemin de données proche
de celui utilisé pour l'approche « cycle unique » mais en
optimise l'utilisation : le « pipelining » où plusieurs
instructions seront exécutées en même temps
pipelining
● une analogie : le lavage du linge
18h 19h 20h 21h 22h 23h 0h 1h 2h
heure
pipelining
● une meilleure utilisation du matériel :
18h 19h 20h 21h

heure
● le temps d'exécution de
chaque instruction reste le
même
● mais pour un grand nombre
d 'opérations, le facteur
d'accélération peut
atteindre 4
pipelining
● on va réaliser un pipeline avec les 5 étapes (maximum)
de l'exécution des instructions
1) aller chercher l'instruction en mémoire (IF : Instruction
Fetch)
2) lire les registres impliqués en même temps que l'on décode
(ID : Instruction Decode)
3) exécuter l'instruction (R format) ou calculer l'adresse (EX)
4) accéder à un opérande en mémoire (MEM)
5) écrire dans un registre (lw) (WB : Write Back)
IF ID EX MEM WB
accès accès
en lecture en écriture
pipelining
● amélioration du temps d'exécution du programme (et non
pas de l'instruction)
➢ temps typiques pour la réalisation des étapes
instruction Reg Data Reg
Classe ALU Total
fetch read access write
load word (lw) 200ps 100 ps 200 ps 200 ps 100 ps 800 ps
store word (sw) 200 ps 100 ps 200 ps 200 ps 700 ps
R format (add, ...) 200 ps 100 ps 200 ps 100 ps 600 ps
branch (beq) 200 ps 100 ps 200 ps 500 ps
➢ on a supposé que les multiplexeurs, unités de contrôle,

accès au registre PC et unités d'extension du bit de signe
n'ont aucun délai
pipelining
● exemple pour 3 instructions « indépendantes »
➢ en mode « cycle unique »
0 200 400 600 800 1000 1200 1400 1600 1800
temps
data
lw $1, 100($0) fetch Reg ALU Reg
access
data
access
800 ps
lw $3, 300($0) fetch Reg
800 ps
2400 ps
instructions
➢ en mode « pipelining »
0 200 400 600 800 1000 1200 1400 1600 1800
temps
data
access
data
200 ps access
data
200 ps access
200 ps 200 ps 200 ps 200 ps 200 ps

instructions
1400 ps
on est limité par la ressource la plus lente (ALU ou accès mémoire)

pipelining
● il peut se produire des conflits entre les instructions dans
le pipeline : « aléas »
➢ aléas « structurels »
➢ aléas « de données »
➢ aléas « de contrôle »
aléa structurel
● exemple
➢ si on n'avait qu'une seule mémoire pour les instructions et
les données
0 200 400 600 800 1000 1200 1400 1600 1800
temps
data
access
data
access
data
access
data
add $4, $1, $2 fetch Reg ALU Reg
access
instructions
aléa structurel
● exemple
➢ si on n'avait qu'une seule mémoire pour les instructions et
les données
0 200 400 600 800 1000 1200 1400 1600 1800
temps
data
access
data
access
data
access
data
access
instructions
➢ aléa structurel dès la 4ème instruction dans le pipeline
aléas de données
● quand le déroulement du pipeline est bloqué car on doit
attendre la fin d'une instruction pour exécuter une des
suivantes
● exemple :
add $s0, $t0, $t1
sub $t2, $s0, $t3
on a besoin de $s0 produit par add pour décoder sub
add $s0, $t0, $t1 IF ID EX MEM WB
sub $2, $s0, $t3 IF ID EX MEM WB
aléas de données
● le compilateur ne peut pas toujours éviter cet aléa
● une première solution : bloquer temporairement le
pipeline
bubble bubble bubble bubble bubble
aléas de données
● autre solution, plus performante : faire suivre (forward) la
donnée (quand c'est possible)
aléas de données
● parfois nécessaire de faire en plus un blocage temporaire
lw $s0, 20($t1) IF ID EX MEM WB
aléas de contrôle
● quand il faut faire un choix basé sur le résultat d'une
instruction
● exemple : instruction de branchement
➢ on suppose que l'on a rajouté du matériel pour comparer le
contenu des registres, calculer l'adresse de branchement et
mettre à jour le compteur de programme pendant la 2ème
étape
➢ si le branchement est pris, on va à l'instruction PC+4+offset
(ici un or)
➢ sinon on va à PC+4 (ici lw)
beq $1, $2, 40
lw $3, 300($0)
…
or $7, $8, $9
aléas de contrôle
● la solution la plus simple consiste à bloquer
systématiquement le pipeline à chaque branchement
0 200 400 600 800 1000 1200 1400
temps
data
access
data
beq $1, $2, 40 fetch Reg ALU Reg
access
bubble bubble bubble bubble
data
or $7, $8, $9 fetch Reg ALU Reg
access
instructions
aléas de contrôle
● pour améliorer les performances : prédictions
➢ on suppose a priori que le branchement n'est pas pris
0 200 400 600 800 1000 1200 1400
temps
data
access
data
access
data
access
instructions
➢ si le branchement est pris, on va à l'instruction or en
introduisant un blocage
0 200 400 600 800 1000 1200 1400
temps
data
access
data
access
bubble bubble bubble bubble
data
or $7, $8, $9 fetch Reg ALU Reg
access
instructions
plan du cours
➢ contrôle
➢ contrôle
chemin de données en mode pipeline
● rappel : cycle unique
Add Add
4 Résultat
Décal.
gauche
2 bits code
opération
Source Registre 4 Ecriture
PC lecture #1
Données mémoire
lecture #1 Mémoire
Registre vers
lecture #2 Zéro registre
Lecture Source
adresse ALU ALU
M Registres Adresse
Résultat
u PC Données
M
instruction Registre Données lues
x u
écriture lecture #2 M
Mémoire
instructions
Données
à écrire
Ecriture
registre
Lecture
Ext. 32
mémoire
16
bit de
signe
Instruction fetch execute memory write
access back
Instruction
decode
les transferts se font
Add Add de gauche à droite
4 Résultat sauf
Décal.
gauche
2 bits code
opération
Source Registre 4 Ecriture
PC lecture #1
Données mémoire
lecture #1 Mémoire
Registre vers
lecture #2 Zéro registre
Lecture Source
adresse ALU ALU
M Registres Adresse
Résultat
u PC Données
M
instruction Registre Données lues
x u
écriture lecture #2 M
Mémoire
instructions
Données
à écrire
Ecriture
registre
Lecture
Ext. 32
mémoire
16
bit de
signe
● chaque étape a son chemin de données propre
➢ représenté par le composant essentiel du chemin
temps CC1 CC2 CC3 CC4 CC5 CC6 CC7
(en cycles d'horloge)
lw $1, 100($0) IM Reg ALU DM Reg
instructions
➢ pour mémoriser des données pour les étages en aval :
besoin de registres intermédiaires
exemple de l'exécution d'une instruction lw
IF/ID ID/EX EX/MEM MEM//WB
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
lecture #2 Zéro lues
Lecture
M adresse Registres ALU M
Résultat Adresse u
u PC
x instruction Registre Données M Mémoire x
écriture lecture #2 u
Données données
écriture
x
Mémoire
instructions Données
à écrire
16 Ext. 32
bit de
signe
lw
instruction fetch
Add Add
4 Résultat
Décal.
gauche
2 bits
lecture Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
écriture
16 Ext. 32
bit de
signe
lw
instruction decode

écriture
lecture
Add Add
4 Résultat
lecture Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
lw
execution
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
lw
Memory
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
lw
Write-back
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
exemple de l'exécution d'une instruction sw sw
execution
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
sw
Memory
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
sw
Write-back
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
lw
Write-back
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
? 16 Ext.
bit de
32
signe
● chemin de données corrigé
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
16 Ext. 32
bit de
signe
Add Add
4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Lecture
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
portions du
chemin de données 16 Ext. 32
utilisées pour une bit de
signe
instruction lw
● représentation graphique du pipeline
➢ pas facile car plusieurs instructions sont exécutées
simultanément
● 2 styles
➢ diagramme pour plusieurs cycles
➢ diagramme pour un seul cycle d'horloge
● exemple
lw $10, 20($1)
sub $11, $2, $3
add $12, $3, $4
lw $13, 24($1)
add $14, $5, $6
● vision sur plusieurs cycles d'horloge
CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9
instructions
du programme
sub $1, $2, $3 IM Reg ALU DM Reg
add $12, $3, $4 IM Reg ALU DM Reg
● vision sur plusieurs cycles d'horloge
instructions
du programme Instruction Instruction data
Execution Write-back
lw $10, 20($1) fetch decode access
Instruction Instruction data

sub $1, $2, $3 Execution Write-back
fetch decode access

add $12, $3, $4 Execution Write-back
fetch decode access

lw $13, 24($1) Execution Write-back
fetch decode access

add $14, $5, $6 Execution Write-back
fetch decode access
add $14, $5, $6 lw 13, 24($1) add $12, $3, $4 sub $11, $2, $3 lw 10, 20($1)
instruction fetch instruction decode execution memory write-back
quel Add Add

cycle ? 4 Résultat
Décal.
gauche
2 bits
Registre
lecture #1Données
lecture #1 Données
Registre
Zéro lues
Lecture lecture #2
Résultat Adresse u
u PC
Données données
écriture
x
Mémoire
à écrire
● vision sur
un seul 16 Ext. 32
cycle bit de
signe
plan du cours
➢ contrôle
➢ contrôle
contrôle en mode pipeline
● on réutilise autant que faire se peut les éléments de
l'implémentation cycle unique
➢ même nomenclature
➢ même logique de contrôle pour l'ALU
➢ compteur PC chargé à chaque cycle de l'horloge : pas
besoin d'une ligne de contrôle spécifique (même
raisonnement pour les registres du pipeline)
● implémentation cycle unique
0
M
Add RegDest Add u
Branch
MemRead x
ALUOp Décal. 1
Contrôle MemtoReg gauche
instruction [31:26] Source
ALUSrc
RegWrite 2 bits PC
instruction [25:21]
Registre
lecture #1 Données
instruction [20:16]
lecture #1 Zéro
Lecture Registre
Registres Adresse 1
PC 0 Résultat Données
0 M
instruction M lues
u
écriture lecture #2 u Mémoire x
x 0
Données x données
Mém. instruction 1 écriture 1
à écrire
Ext. Contrôle
bit de ALU
16 signe 32
instruction [15:0]
instruction [5:0]
PCSrc
Branch
Add
Add
4 Décal. Résultat
RegWrite gauche
2 bits
Registre
lecture #1Données
lecture #1
Registre Zéro
Lecture lecture #2 ALUSrc
0 ALU MemWrite MemtoReg
M adresse Registres
Résultat
u PC 0
1 instruction M Données
x Registre Données 0
écriture lecture #2
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
instructions données x
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
u
Instr 1
x
[15-11]
RegDest
● on établit les lignes de contrôle à chaque étape du
pipeline
● chaque composant du chemin de données n'est utilisé
qu'à une étape → 5 groupes de lignes
IF ID PCSrc
Branch
Add
Add
4 Décal. Résultat
RegWrite gauche
2 bits
Registre
lecture #1Données
lecture #1
Registre Zéro
M adresse Registres
Résultat
u PC 0
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
u
Instr 1
x
[15-11]
RegDest
pipeline
➢ IF : rien de spécial (les lignes pour écrire le PC et la lecture
de la mémoire instruction sont toujours assertées)
➢ ID : rien de spécial (la lecture du register file est toujours
assertée
EX PCSrc
Branch
Add
Add
4 Décal. Résultat
RegWrite gauche
2 bits
Registre
lecture #1Données
lecture #1
Registre Zéro
M adresse Registres
Résultat
u PC 0
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
u
Instr 1
x
[15-11]
RegDest
pipeline
assertée)
➢ EX : il faut établir RegDest, ALUOp et ALUSrc
PCSrc MEM
Branch
Add
Add
4 Décal. Résultat
RegWrite gauche
2 bits
Registre
lecture #1Données
lecture #1
Registre Zéro
M adresse Registres
Résultat
u PC 0
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
u
Instr 1
x
[15-11]
RegDest
pipeline
assertée)
➢ Mem : il faut établir Branch, MemRead et MemWrite
✔ PCSrc est établi à partir de Branch et éventuellement la ligne
Zero de l'ALU (si Branch est vrai)
PCSrc WB
Branch
Add
Add
4 Décal. Résultat
RegWrite gauche
2 bits
Registre
lecture #1Données
lecture #1
Registre Zéro
M adresse Registres
Résultat
u PC 0
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
u
Instr 1
x
[15-11]
RegDest
pipeline
assertée)
➢ Mem : il faut établir Branch, MemRead et MemWrite
✔ PCSrc est établi à partir de Branch et éventuellement la ligne
Zero de l'ALU (si Branch est vrai)
➢ WB : il faut établir MemtoReg et RegWrite
Execution Memory Write-back

Instr.
Mem- Mem- Reg- Memto-
RegDest ALUOP1 ALUOP0 ALUSrc Branch
Read Write Write Reg
R-format 1 1 0 0 0 0 0 1 0
lw 0 0 0 1 0 1 0 1 1
sw X 0 0 1 0 0 1 0 X
beq X 0 1 0 1 0 0 0 X
● les lignes de contrôle sont établies au décodage puis
transmises via les registres du pipeline
WB
Mem
Contrôle
WB
Instruction
EX
Mem
WB
IF/ID ID/EX EX/MEM MEM/WB

PCSrc
ID/EX
WB EX/MEM
Contrôle M MEM//WB
WB
IF/ID
EX M WB
Add Branch
Add
4
Décal. Résultat
RegWrite gauche
2 bits
Registre ALUSrc
lecture #1Données MemWrite
lecture #1
Registre Zéro
Lecture lecture #2 MemtoReg
0 ALU
M adresse Registres
Résultat
u PC 0
u lues
1
x Adresse M
Données Mémoire u
Mémoire écriture
Données 1
Ext. à écrire
32 Contrôle
Instr 6
bit de ALU
[15-0]
signe
MemRead
Instr 0
[20-16]
M ALUOp
1 u
Instr
x
[15-11] RegDest
plan du cours
➢ contrôle
➢ contrôle
gestion des aléas
● les exemples précédents sont « sympas » : pas
d'interférences entre les différentes instructions
● autre exemple (moins sympa)
sub $2, $1, $3
and $12, $2, $5
or $13, $6, $2
add $14, $2, $2
lw $15, 100($2)
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
and $12, $2, $5 IM Reg ALU DM Reg
or $13, $8, $2 IM Reg ALU DM Reg
sw $15, 100($2) IM Reg ALU DM Reg
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
pas de problème
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
peut être résolu en modifiant le hardware
sub $2, $1, $3 IM Reg ALU DM Reg écriture pendant la 1ère moitié du cycle
lecture pendant la 2nde moitié du cycle
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme aléas
sub $2, $1, $3 (ligne de dépendance
IM Reg ALU DM Reg
vers l'arrière)
gestion des aléas
● le résultat dont a besoin est disponible dès la fin de
l'étape EX de l'instruction sub $2, $1, $3 : CC3
● les instructions and $12, $2, $5 et or $13, $6, $2
en ont besoin au début de leur étape EX, soit CC4 et CC5
● il « suffit » de forwarder le résultat dès qu'il est disponible,
sans attendre qu'il soit disponible à la lecture dans le
register file
● nécessaire d'être capable de détecter les aléas
détection des aléas (1)
● on se limite au cas où l'on veut forwarder vers une
instruction dans l'étape EX
➢ opération d'ALU (instruction de type R)
➢ opération de calcul d'adresse
● aléa quand une instruction a besoin du contenu d'un
registre pour son étape EX alors qu'une instruction
précédente va écrire ce même registre dans son étape WB
● on se repère en utilisant les buffers entre les étapes :
➢ ID/EX.RegisterRs se réfère au numéro du registre Rs se
trouvant dans le buffer ID/EX du pipeline
Rappel
● format des instructions MIPS pour les instructions de type
R, de branchement et d'accès à la mémoire
champ 0 rs rt rd shamt funct

position des bits 31:26 25:21 20:16 15:11 10:6 5:0
instructions de type R (exemple : add rd, rs, rt )
champ 3510 ou 4310 rs rt offset

instructions d'accès à la mémoire (exemple : lw rt, offset(rs) )
champ 410 rs rt offset

instructions de saut conditionnel (exemple : beq rs, rt, offset)
● on se limite au cas où l'on veut forwarder vers une
instruction dans l'étape EX
➢ opération d'ALU (instruction de type R)
➢ opération de calcul d'adresse
● aléa quand une instruction a besoin du contenu d'un
registre pour son étape EX alors qu'une instruction
précédente va écrire ce même registre dans son étape WB
● on se repère en utilisant les buffers entre les étapes :
➢ exemple : ID/EX.RegisterRs se réfère au numéro du registre
Rs se trouvant dans le buffer ID/EX du pipeline
● 2 paires de conditions d'aléas
➢ 1.a : EX/MEM.RegisterRd = ID/EX.RegisterRs
➢ 1.b : EX/MEM.RegisterRd = ID/EX.RegisterRt
➢ 2.a : MEM/WB.RegisterRd = ID/EX.RegisterRs
➢ 2.b : MEM/WB.RegisterRd = ID/EX.RegisterRt
● sub $2, $1, $3
and $12, $2, $5
➢ est un aléa de type 1.a
➢ EX/MEM.RegisterRd = ID/EX.RegisterRs = $2
● sub $2, $1, $3
or $13, $6, $2
➢ est un aléa de type 2.b
➢ MEM/WB.RegisterRd = ID/EX.RegisterRt = $2
● pas d'aléa pour les autres dépendances
● les règles précédentes ne sont pas suffisantes
➢ certaines instructions n'écrivent pas dans le register file et
elles provoqueraient un forward là où il n'est pas utile
✔ test de la ligne de commande RegWrite dans le champ WD
des buffers du pipeline
➢ certaines instructions qui utilisent le registre $0 comme
destination (exemple : sll $0 $1, 2)
✔ pas nécessaire de forwarder des résultats vers $0
✔ les conditions 1 et 2 sont valides si EX/MEM.RegisterRd ≠ 0
et MEM/WB.RegisterRd ≠ 0
● nécessaire aussi d'identifier correctement les données à
forwarder
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
valeur de EX/MEM X X X -20 X X X X X
valeur de MEM/WB X X X X -20 X X X X
instructions
du programme
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
gestion des aléas
valeur du
registre $2 10 10 10 10 10/-20 -20 -20 -20 -20
instructions
du programme
gestion des aléas
ID/EX EX/MEM MEM/WB
ALU
registers
data M
memory u
x
● modification du chemin de données

pour les seules instructions de type R (add, sub, and, or)
gestion des aléas
ID/EX EX/MEM MEM/WB
M
u
x
ForwardA ALU
registers
M
data M
u
memory u
x
x
ForwardB
Rs
Rt
Rt
M
Rd u EX/MEM.RegisterRd
Forwarding
unit MEM/WB.RegisterRd
pour les seules instructions de type R (add, sub, and, or)

gestion des aléas
Mux control Source Explication
ForwardA = 00 ID/EX le premier opérande de l'ALU vient du register file
le premier opérande de l'ALU est forwardé du

ForwardA = 10 EX/MEM
résultat précédent de l'ALU
le premier opérande de l'ALU est forwardé de la
ForwardA = 01 MEM/WB
mémoire donnée ou d'un résultat précédent de l'ALU
ForwardB = 00 ID/EX le second opérande de l'ALU vient du register file
le second opérande de l'ALU est forwardé du

ForwardB = 10 EX/MEM
résultat précédent de l'ALU
le second opérande de l'ALU est forwardé de la
ForwardB = 01 MEM/WB
mémoire donnée ou d'un résultat précédent de l'ALU
gestion des aléas
● détection des aléas EX
if (EX/MEM.RegWrite
and (EX/MEM.RegisterRd ≠0)
and (EX/MEM.RegisterRd = ID/EX.RegisterRs)) ForwardA=10
if (EX/MEM.RegWrite
and (EX/MEM.RegisterRd ≠0)
and (EX/MEM.RegisterRd = ID/EX.RegisterRt)) ForwardB=10
● détection des aléas MEM

if (MEM/WB.RegWrite
and (MEM/WB.RegisterRd ≠0)
and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) ForwardA=01
if (MEM/WB.RegWrite
and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) ForwardB=01
gestion des aléas
● dans l'exemple précédent, pas d'aléa dans l'étage WB car
résolu par un mécanisme interne au register file
● si on considère la suite d'instructions
add $1, $1, $2
add $1, $1, $3
add $1, $1, $4
problème à l'étage WB nécessitant un forward
● équations modifiées pour en tenir compte :
if (MEM/WB.RegWrite
and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0)
and (EX/MEM.RegisterRd ≠ ID/EX.RegisterRs))
and (MEM/WB.RegisterRd = ID/EX.RegisterRs)) ForwardA=01
if (MEM/WB.RegWrite
and not (EX/MEM.RegWrite and (EX/MEM.RegisterRd ≠0)
and (EX/MEM.RegisterRd ≠ ID/EX.RegisterRt))
and (MEM/WB.RegisterRd = ID/EX.RegisterRt)) ForwardB=01
gestion des aléas
Modifications nécessaires ID/EX
WB EX/MEM
Contrôle M MEM//WB
WB
IF/ID
EX M WB
M
u
x
Registre ForwardA
lecture #1Données
lecture #1
Registre Zéro
Lecture lecture #2
ALU
adresse Registres
Résultat
PC
instruction M Données
Registre Données lues
u
x Adresse M
Données Mémoire u
Mémoire écriture
Données
à écrire
ForwardB
IF/ID.RegisterRs
IF/ID.RegisterRt
IF/ID.RegisterRt M EX/MEM.RegisterRd
IF/ID.RegisterRd
u
x
Forwarding
unit
MEM/WB.RegisterRd
gestion des aléas
ID/EX
WB EX/MEM
NB : M
Contrôle WB MEM//WB
beaucoup d'éléments IF/ID
EX M WB
du chemin de données
non représentés
(branchements, M
u
extension du bit de x
signe, etc...)
Registre ForwardA
lecture #1Données
lecture #1
Registre Zéro
Lecture lecture #2
ALU
adresse Registres
Résultat
PC
u
x Adresse M
Données Mémoire u
Mémoire écriture
Données
à écrire
ForwardB
IF/ID.RegisterRs
IF/ID.RegisterRt
IF/ID.RegisterRd
u
x
Forwarding
unit
MEM/WB.RegisterRd
gestion des aléas
● les développements précédents montrent la complexité
de la gestion de quelques aléas
● ce ne sont pas les seuls...
➢ succession d'opérations lw et sw
➢ instructions de type li (load immediate)
➢ sauts conditionnels
➢ etc...
● nécessaire de prévoir les conditions de forwarding
prenant en compte ces aléas
➢ complexité accrue du chemin de données et du contrôle
gestion des aléas
● certaines situations imposent de bloquer temporairement
le pipeline (« stalls »)
➢ par exemple quand une instruction veut lire un registre qui
vient d'être accédé en écriture par l'instruction précédente
(lw)
gestion des aléas
instructions encore en train de lire en

du programme mémoire quand on en a
besoin dans l'ALU
lw $2,20( $1) IM Reg ALU DM Reg
slt $1, $6, $3 IM Reg ALU DM Reg
gestion des aléas
● nécessaire de bloquer temporairement le pipeline
● nécessaire de détecter l'aléa durant l'étape ID pour
ajouter le blocage dans le contrôle
l'instruction est un load
if (ID/EX.MemRead and
((ID/EX.RegisterRt = IF/EX.RegisterRs) or
(ID/EX.RegisterRt = IF/ID.RegisterRt)))
stall the pipeline
le registre de destination
● ensuite la logique de forwarding peut du load correspond à un
des registres source dans
gérer la dépendance et le processus l'instruction à l'étape ID
d'exécution peut se poursuivre
gestion des aléas
● si l'instruction dans l'étape ID est bloquée, alors
l'instruction dans l'étape IF doit l'être aussi
➢ gel du registre PC et du buffer IF/ID
● les étapes en aval (EX et suivantes) sont « occupées » en
exécutant une instruction nop (no operation)
Instr.
R-format 1 1 0 0 0 0 0 1 0
lw 0 0 0 1 0 1 0 1 1
sw X 0 0 1 0 0 1 0 X
beq X 0 1 0 1 0 0 0 X
gestion des aléas
● si l'instruction dans l'étape ID est bloquée, alors
l'instruction dans l'étape IF doit l'être aussi
➢ gel du registre PC et du buffer IF/ID
● les étapes en aval (EX et suivantes) sont « occupées » en
exécutant une instruction nop (no operation)
Instr.
R-format 0 0 0 0 0 0 0 0 0
lw 0 0 0 0 0 0 0 0 0
sw 0 0 0 0 0 0 0 0 0
beq 0 0 0 0 0 0 0 0 0
● obtenu en forçant à 0 les lignes de contrôle dans ID/EX

➢ automatiquement transmis aux buffers en aval
gestion des aléas
instructions
du programme
lw $2,20( $1) IM Reg ALU DM Reg
and devient nop IM Reg ALU DM Reg
gestion des aléas
PCWrite ID/EX.MemRead
unité de
détection
IF/ID.Write
d'aléas
ID/EX
WB EX/MEM
M
Contrôle u M
WB MEM//WB
IF/ID 0 x EX M M WB
u
x
Registre ForwardA
lecture #1Données
lecture #1
Registre Zéro
Lecture lecture #2
ALU
adresse Registres
Résultat
PC
u
x Adresse M
Données Mémoire u
Mémoire écriture
Données
à écrire
ForwardB
IF/ID.RegisterRs
IF/ID.RegisterRt
IF/ID.RegisterRd
u
x
Forwarding
unit
MEM/WB.RegisterRd
gestion des aléas
● les aléas vus jusqu'à présent sont des aléas structurels
ou de données
● les aléas de contrôles sont liés aux branchements
● complexes à gérer
➢ supposer que le branchement n'est pas pris
➢ tester le plus rapidement possible (dès l'étape ID) la
condition
➢ si nécessaire (branchement pris) vider le pipeline (flush) et
aller vers la nouvelle branche
● les exceptions sont gérées comme les aléas de contrôle
➢ stockage de la cause et du compteur PC dans des registres
dédiés, puis branchement non conditionnel à une adresse
réservée (8000 0180hex)
● hors du champ de ce cours... (→ IRM5 SyCA)
plan du cours
➢ contrôle
➢ contrôle
hiérarchie des mémoires - caches
● l'accès à la mémoire est pénalisant (lent par rapport à
l'horloge de la CPU)
● difficile d'avoir une grande quantité de mémoire à proximité
immédiate du processeur
● pour créer une situation optimisant les ressources
disponibles, on utilise le fait que toutes les données ou les
instructions ne sont pas accédées avec la même
probabilité
➢ localité temporelle : si un item a été référencé, il sera
probablement référencé encore dans un court laps de temps
➢ localité spatiale : si un item a été référencé, les items voisins
le seront probablement aussi
● la mémoire disponible sera organisée en plusieurs couches
suivant une hiérarchie
hiérarchie des mémoires
● organisation de la mémoire en plusieurs niveaux pour
fournir la quantité nécessaire avec la technologie
fournissant le meilleur compromis vitesse/coût
● plus on est « loin » de la CPU, moins on a besoin de
vitesse
CPU vitesse taille coût technologie
la plus la plus la plus

mémoire SRAM
rapide petite chère
mémoire DRAM
la plus la plus la moins disque magnétique,

mémoire
lente grande chère mémoire flash, SDD
● les mouvements de données ne se font qu'entre niveaux
adjacents
● la quantité minimum transférée est un « bloc »
CPU niveau 0
● si les données cherchées sont

dans le niveau supérieur :
niveau 1 « succès » ou « hit »
sinon : « échec » ou « miss »
(avec pénalité temporelle)
● la bonne compréhension de la
niveau 2 hiérarchie est essentielle pour
obtenir les meilleures
performances
● La hiérarchie le plus souvent rencontrée
➢ CPU
➢ mémoire cache
➢ mémoire principale
➢ disque
● les points importants pour optimiser la performance :
➢ placement du bloc dans le niveau supérieur
➢ identification du bloc
➢ remplacement du bloc en cas d'échec
➢ stratégie d'écriture
exemple d'un cache très simple
● dans notre exemple
➢ les requêtes du processeur sont d'un seul mot
➢ les blocs du cache sont constitués d'un seul mot
● problème :
➢ comment savoir si un mot est dans le cache ?
➢ si il y est, comment le trouver ?
● un mot ⇔ un bloc ⇒ facile de savoir si le mot est présent
● pour placer de façon ordonnée les mots dans le cache, on
va faire correspondre la position dans le cache avec
l'adresse en mémoire du mot (« direct mapping »)
➢ si la taille du cache est une puissance de 2, la position dans
le cache sera donnée par les bits de poids faible de
l'adresse en mémoire
● cache à 8 places pour une mémoire de 32 mots
000
001
010
011
100
101
110
111
00000 11111
● cache à 8 places pour une mémoire de 32 mots
000
001
010
011
100
101
110
111
00001 00101 01001 01101 10001 10101 11001 11101
● pour savoir si la donnée dans le cache correspond au mot
demandé : ajout d'un ensemble de tags au contenu du
cache
➢ les bits de poids fort de l'adresse mémoire non utilisés pour
l'adresse dans le cache
➢ plus un bit indiquant si le contenu du cache est valide
(adresse cache déjà utilisée pour une donnée mémoire)
● état du cache
TD
taille du cache
● adresse du mot cherché codée sur 32 bits
➢ les 2 derniers bits sont 00 (on adresse des octets)
● les blocs peuvent contenir plusieurs mots
● pour un cache de 2n blocs, chacun contenant 2m mots
(2m+2 octets)
➢ n bits pour identifier l'index des blocs
➢ 32 – (n+m-2) bits pour le tag
➢ + 1 bit de validation
➢ nombre de bits = 2n x (taille du bloc + taille du tag + 1)
accès au cache
● pour un cache de 1024 blocs de 1 mot
31 30 … 13 12 11 …. 2 1 0
Tag 20 Données
Index 10
Hit
Index V Tag Données
transférées
0 si hit est vrai
1
...
...
...
1021
1022
1023
=
32
accès au cache
● dans le cas d'un échec du cache, la procédure pour
accéder à la donnée dans le niveau suivant de la
hiérarchie est complexe, nécessitant, entre autres, des
blocages du pipeline
➢ hors du champ de ce cours...
accès au cache en écriture
● contrainte : garder la cohérence entre le contenu du
cache et le contenu de la mémoire
● plusieurs stratégies possibles :
➢ écrire systématiquement dans le cache et aussi dans la
mémoire (write-through)
✔ peut ralentir considérablement le processeur
➢ écrire dans le cache et dans un buffer et vider le buffer
dans la mémoire par un système indépendant
✔ les performances vont dépendre de la vitesse d'accès à la
mémoire en écriture vis-à-vis du taux d'opérations d'écriture
que génère le processeut
➢ n'écrire que dans le cache et vider le cache dans la
mémoire uniquement quand le bloc doit être remplacé
(write-back)
✔ complexe à gérer
Conclusion
● on a vu comment implémenter un processeur « simple »
dans différentes configurations d'exécution
➢ cycle unique
➢ multi-cycles
➢ pipeliné
● même pour cette architecture simple, l'obtention de
meilleures performances se fait au prix d'une complexité
accrue, en particulier pour les opérations de contrôle
● la compréhension du fonctionnement interne du
processeur peut aider à optimiser la façon de programmer
en particulier pour les accès aux données
à suivre...
Périphériques

Chapitre 1 CPU

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

Chapitre 1 CPU

Transféré par

Droits d'auteur :

Formats disponibles

Unité Centrale de

●Le PC peut recevoir l'adresse

●Le PC peut recevoir l'adresse

● Les données écrites dans les

● Les données écrites dans les

●Pour choisir le bon chemin, on va

● une unité de contrôle utilisant

● l'incrémentation du PC est gérée

a31 CarryIn Résultat31

a31 CarryIn Résultat31

a31 CarryIn Résultat31

➢ d'une mémoire pour stocker adresse de

add $t0,$t1,$t2 place la somme de $t1 et $t2 dans $t0

a invert binvert (+CarryIn) Lignes de contrôle

a invert binvert (+CarryIn) Lignes de contrôle

a invert binvert (+CarryIn) Lignes de contrôle

champ 3510 ou 4310 rs rt offset

champ 410 rs rt offset

LW 00 load word XXXXXX add 0010

➢ utilise le champ de fonction et un champ de contrôle de 2

ALUOp Champ de fonction

11 jamais utilisé toujours 10

ALUOp Champ de fonction

instruction [5:0] ALUOp

add $t1,$t2,$t3 instruction [5:0]

add $t1,$t2,$t3 instruction [5:0]

add $t1,$t2,$t3 instruction [5:0]

$t3 $t2 $t2 et $t3

add $t1,$t2,$t3 instruction [5:0]

add $t1,$t2,$t3 instruction [5:0]

add $t1,$t2,$t3 instruction [5:0]

pas d'accès mémoire

add $t1,$t2,$t3 instruction [5:0]

lw $t1,offset($t2) instruction [5:0]

lw $t1,offset($t2) instruction [5:0]

lw $t1,offset($t2) instruction [5:0]

offset étendu à 32 bits et

offset + $t2 est

lw $t1,offset($t2) instruction [5:0]

lw $t1,offset($t2) instruction [5:0]

$t1 le contenu est

lw $t1,offset($t2) instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

beq $t1,$t2,offset instruction [5:0]

pas d'accès mémoire

beq $t1,$t2,offset instruction [5:0]

j address instruction [5:0]

j address instruction [5:0]

PCWrite Outputs ALUOp

PCWrite Outputs ALUOp

PCWrite Outputs ALUOp

1. aller chercher l'instruction

PCWrite Outputs ALUOp

1. aller chercher l'instruction

PCWrite Outputs ALUOp

1. aller chercher l'instruction

PCWrite Outputs ALUOp 00

1. aller chercher l'instruction

PCWrite Outputs ALUOp

PCWrite Outputs ALUOp