Etapes d`exécution des instructions

Etapes d'exécution des instructions
Etapes d'exécution des instructions
Recherche
instruction
Recherche
opérandes
Exécution
Ecriture
résultat
4. 1
Etapes d'exécution des instructions
1. Cycle d'exécution des instructions
Modèle de Von Neuman
• Le CPU fait une boucle sans fin pour exécuter le programme chargé
en mémoire centrale
• Chaque étape correspond à une modification d'un composant du
chemin de données (la mémoire ou les registres)
• Les étapes dépendent de l'instruction à exécuter : opération à
effectuer et mode d'adressage
• Quelle que soit l'architecture, on retrouve des étapes similaires
(même fonction) mais les étapes dépendent du chemin de données
4. 2
Etapes d'exécution des instructions
lecture en
lecture du ou
mémoire instruction
à l'adresse PC
des opérandes
lecture et
interprétation
des champs
d'instruction
écriture des résultats
calculs
traitement des interruptions
matérielles (souris, clavier, ...)
conditions d'erreur (division
par 0,overflow, ...), défaut de page
calcul de la nouvelle
valeur de PC
(dépend du format de l'instruction)
©W. Stallings « Computer Organization and Architecture »
4. 3
Etapes d'exécution des instructions
●
Lecture d’instruction
•
●
Décodage
•
•
●
•
Accès aux registres (si mode registre)
Calcul d’adresse et recherche d’opérandes mémoire (si mode mémoire)
Exécution
•
•
●
Lecture éventuelle des autres mots d'instruction (selon le format)
Ces valeurs sont stockées dans l'unité centrale dans des registres internes (registre
d'opérande et de données)
Recherche d’opérandes
•
●
Charger le 1er mot d'instruction de la mémoire principale vers le registre d'instruction
Calcul dans l’ALU pour les instructions arithmétiques ou logiques
Calcul de l’adresse de branchement pour les instructions de contrôle
Ecriture résultat
•
•
Modification de l’opérande destination pour les instructions arithmétiques ou logiques
Modification de PC pour les instructions de contrôle
4. 4
Etapes d'exécution des instructions
Exemple : PROCSI
RD1
RD2
R/Wreg
REG
SR
SP
ROP
CSreg
3
PC
IR
BUS
ADDRESS_BUS
RAD
DATA_BUS
16
AS
MEMOIRE
instructions
DS
données
4. 5
R/W
contrôle
Etapes d'exécution des instructions
Exemple de décomposition en étapes pour PROCSI
add R2, # 80
R2 <- R2 + 80
lecture instruction
rad  pc
ir  mem[rad]
pc  pc + 1
lecture du code instruction
décodage
rad  pc
rop  mem[rad]
pc pc + 1
lecture du 2ème mot d’instruction
(constante 80)
recherche
opérande
rd1  reg[ir(0..2)]
rd2  rop
ir(0..2) : bits 0, 1 et 2 de ir qui contiennent
le code du registre destination
reg[ir(0..2)] est le registre destination
exécution
rd1  rd1 + rd2
écriture
résultat
reg[ir(0..2)]  rd1
4. 6
Etapes d'exécution des instructions
ADD R2, #80
RD1
RD2
R/Wreg
6
REG
SR
CSreg
3
PC + 1
SP
ROP
IR
PC
BUS
000000 0100X010
DATA_BUS
16
ADDRESS_BUS
RAD
1) Lecture instruction
AS
MEMOIRE
PC:000000 0100X010
80
instructions
DS
R/W
données
4. 7
Légende :
en 1er
en 2ème
en 3ème
Etapes d'exécution des instructions
RD1
RD2
R/Wreg
6
REG
SR
CSreg
3
80 PC + 1
SP
ROP
IR
PC
000000 0100X010
BUS
16
2) décodage
DATA_BUS
ADDRESS_BUS
RAD
AS
MEMOIRE
PC :000000 0100X010
80
instructions
DS
R/W
données
4. 8
Etapes d'exécution des instructions
6
RD1
RD2
80
R/Wreg
010
SR
SP
ROP
6
REG
CSreg
3
PC
IR
000000 0100X010
BUS
16
3) recherche opérande
DATA_BUS
ADDRESS_BUS
RAD 17
AS
MEMOIRE
DS
000000 0100X010
instructions
R/W
données
4. 9
80
Etapes d'exécution des instructions
86
RD2 80
RD1 6
R/Wreg
6
REG
SR
+
SP
ROP
CSreg
3
PC
IR
BUS
ADDRESS_BUS
RAD 17
DATA_BUS
16
4) Exécution
AS
MEMOIRE
000000 0100X010
instructions
DS
R/W
données
80
4. 10
Etapes d'exécution des instructions
RD1
86
RD2
86 6
010
SR
SP
ROP
REG
R/Wreg
CSreg
3
PC
IR
BUS
16
5) Ecriture résultat
DATA_BUS
ADDRESS_BUS
RAD 17
AS
MEMOIRE
DS
000000 0100X010
instructions
R/W
données
4. 11
80
Etapes d'exécution des instructions
Exemple de décomposition en étapes pour PROCSI
add [80], R3
MEM[80] <- MEM[80] + R3
lecture instruction
rad  pc
ir  mem[rad]
pc  pc + 1
décodage
rad  pc
rop  mem[rad]
pc pc + 1
rop contient 80
rd1  reg[ir(3..5)]
rad  rop
rd2  mem[rad]
ir(3..5) : bits 3, 4 et 5 de ir qui contiennent
le numéro du registre source
reg[ir(3..5)] est le registre source (R3 ici)
rd2 contient MEM[80]
recherche opérande
exécution
rd1  rd1 + rd2
écriture résultat
mem[rad]  rd1
4. 12
Etapes d'exécution des instructions
2. Cycle d'exécution pipeline
Durée : 3 mn
Sens du parcours
Eve
Julie
Anne
Pour manger :
- il faut passer par tous les stands,
- 4 personnes sont servies en même temps.
Aladin
Une personne met 12mn pour être servie.
Toutes les 3mn une personne sort de la
chaîne.
4. 13
Etapes d'exécution des instructions
2.1. Les principes
• Une instruction est divisée en k étapes indépendantes
• Les étapes de plusieurs instructions s'exécutent en parallèle
• Si une étape dure t unités de temps alors pour n instructions :
– sans pipeline : t * k * n unités de temps
– avec pipeline : t * k + t * (n-1) unités de temps
SANS PIPELINE
8 ns
2 2 2 2
i
8 ns
2 2 2 2
i+1
8 ns
2 2 2 2 24 ns
i+2
AVEC PIPELINE
i:
2
i+1:
i+2:
4. 14
8 ns
2
2
2
2
2
2
2
2
2
2
2 12 ns
Etapes d'exécution des instructions
Contraintes pour que le pipeline soit efficace :
– chaque étape a la même durée : pas d'embouteillage !
– chaque instruction passe par les mêmes étapes : contrôle simplifié,
pas de trou dans le pipeline !

Architecture RISC (commercialisé ~ 1986) :
Jeu d'instructions et modes d’adressage simples,
● Accès mémoire par instructions spécialisées (LOAD/STORE),
● Débit d'une instruction par cycle : chaque étape dure un cycle
donc une instruction sort du pipeline sur chaque cycle
●
i:
i+1:
i+2:
1
1
1
1
1
1
1
1
1
4. 15
1
1
1
Etapes d'exécution des instructions
Jeu d'instruction RISC
• plus de registres
AMD 64 bits : registres AX, BX, CX, DX, DI, ... étendus à 32 bits (EAX,
EBX, ...) et à 64 bits (RAX, ...) + 8 registres R8, ..., R15
• moins de modes d'adressage : instructions de calcul en mode registre +
instructions LOAD /STORE
• instructions à 3 opérandes
ARM : add R1, R4, R5
• instructions conditionnelles
AMD 64 bits :
cmp eax, ebx
bnez suite
mov ecx, edx
cmp eax, ebx
cmovz ecx, edx
4. 16
Etapes d'exécution des instructions
2.2. Etages de base
•
LI lecture d'instruction dans le cache d'instruction
•
DE décodage
•
CA calcul dans l'ALU (ou calcul d'adresse mémoire ou de branchement)
•
MEM accès à la mémoire dans le cache des données (pour les instructions
LOAD/STORE)
•
ER écriture résultat (modification des registres ou de PC ou du cache de données)
4. 17
Etapes d'exécution des instructions
Schéma d'exécution temps / étage
Numéro d’instruction
Etages d’exécution
i:
LI
i+1:
DE
CA
ER
LI
DE
CA
ER
LI
DE
CA
ER
LI
DE
CA
ER
4
5
6
7
i+2:
Top d’horloge
i+3:
1
2
3
Sur le top d’horloge 4, il y a exécution en parallèle de l’écriture résultat (ER) de
l’instruction i, du calcul (CA) de l’instruction i + 1, du décodage (DE) de
l’instruction i+2 et de la lecture (LI) de l’instruction i+3
4. 18
Etapes d'exécution des instructions
Exemples de pipeline
• Pentium 4 : 20 étages
• AMD 64
– 12 étages pipeline entier et 17 étages pipeline flottant,
– 8 premiers étages = "Fetch/Decode" + "Pack/Decode" et "Dispatch",
communs aux entiers et aux flottants
• ARM
– ARM 7, 3 niveaux (lecture d'instruction, décodage, exécution)5
– StrongARM (ARM 8, 9 et SA-1) 5 niveaux (lecture d'instruction, lecture
des registres et test de branchement, exécution, écriture cache, écriture
registre)
4. 19
Etapes d'exécution des instructions
2.3. Comment ça marche ?
• Chaque étage est “autonome” : il contient les composants nécessaires pour
réaliser l'étape d'exécution
– LI: accès à la file d'instructions
– DE : accès aux registres
– CA : unité de calcul
– ER : accès registre et mémoire de données
• Accès en parallèle aux ressources
– Registres : deux accès en lecture et un en écriture simultanément
– Mémoire centrale : cache d'instructions et cache de données
• Deux étages successifs partagent les données
– registres de stockages intermédiaires
– l'étage i écrit le résultat, l'étage i+1 lit le résultat
4. 20
Etapes d'exécution des instructions
Exemple : Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
R2 <-R1 + R2
R3 < - R4 + R5»
DE
LI
CA
ER
ALU
PC
Inst
Données
Registres R1=10
R2=8
R3=0
R4=6
R5=3
Mémoire
4. 21
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
DE
add R2,R1,R2
PC
Inst
CA
Add
R2
R1
R2
LI
TOP 1
ER
ALU
Données
Registres R1=10
R2=8
R3=0
R4=6
R5=3
Mémoire
4. 22
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
Inst
accès à R1
et R2
Add
R2
10
PC
Add
R3
R4
R5
add R3,R4,R5
CA
ER
8
DE
LI
TOP 2
ALU
Données
Registres R1=10
R2=8
R3=0
R4=6
R5=3
Mémoire
4. 23
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
CA
ER
PC
Inst
6
10 + 8
Add
Add
R3
accès à R4
et R5
R2
3
18
DE
LI
TOP 3
ALU
Données
Registres R1=10
R2=8
R3=0
R4=6
R5=3
Mémoire
4. 24
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
DE
CA
ER
9
LI
TOP 4
R3
accès à R2
Add
6+3
ALU
PC
Inst
Données
Registres R1=10
R2=8
R3=0
R4=6
R5=3
Mémoire
4. 25
18
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
DE
LI
TOP 5
CA
ER
accès à R3
ALU
PC
Inst
Données
Registres R1=10
R2=18
R3=0 9
R4=6
R5=3
Mémoire
4. 26
Etapes d'exécution des instructions
3. Aléas du pipeline
L'exécution en parallèle rend le contrôle de l'exécution plus complexe :
●
Gestion de l'accès simultané aux ressources partagées
Aléas de données : un étage peut lire une donnée avant qu'elle ait été
mise à jour
• Gestion des instructions de branchement : les instructions dans le pipeline ne
sont pas forcément exécutées
Aléas de contrôle
• Accès à des données d'autres unités fonctionnelles (cas superscalaire)
Aléas structurel
4. 27
Etapes d'exécution des instructions
3.1. Aléas de données
•
•
lecture avant écriture d’un résultat,
écriture du résultat avant lecture de la donnée (exécution dans le désordre)
Exemple:
ADD R1, R2, R3
SUB R4, R1, R5
instruction
ADD
SUB
Ecriture de R1
Aléa de type « lecture avant écriture »
LI
DE
LI
CA
DE
ER
CA
ER
lecture de R1
4. 28
Etapes d'exécution des instructions
Solution 1 : suspension d'exécution
ADD R1, R2, R3
SUB R4, R1, R5
ADD
SUB
LI
Ecriture de R1
DE
LI
CA
DE
ER
CA
ER
lecture de R1
Ecriture de R1
ADD
SUB
LI
DE
LI
CA
susp
ER
susp
DE
CA
lecture de R1
4. 29
ER
Etapes d'exécution des instructions
Solution 2 : bypass
• la sortie de l’ALU est utilisée directement
Pour l’exemple «add R1,R2,R3» suivi de «add R6,R1,R5», lors du décodage
de «add R6,R1,R5», on utilise la valeur de bypass (i.e sortie de l'ALU après calcul
de R2 + R3) au lieu d’aller lire la valeur de R1 dans la RAM.
DE
CA
ER
PC
8
8+0
R1
Add
accès à R1
et R5
R6
8
3
LI
ALU
8
4. 30
Etapes d'exécution des instructions
Exemple de bypass avec l'ARM SA-110
Programme
LDR r1,[r0 + 4]
MOV r2,r1
4. 31
Etapes d'exécution des instructions
3.2. Aléas de contrôle
Les instructions qui suivent une instruction de branchement (jmp) ne doivent pas
être exécutées.
Pourtant, elles sont dans le pipeline  suspension du pipeline
i : jmp 360
i+1
LI
DE
LI
i+2
i+3
A la fin du décodage du « jmp » on sait qu’il s’agit d’un saut
- il ne faut pas exécuter les instructions suivantes
- il faut suspendre l’exécution jusqu’à ce que l’adresse de branchement
soit connue → étage ER
4. 32
Etapes d'exécution des instructions
A la fin de l’étage ER du jmp, on connaît l’adresse de branchement (PC a été modifié)
→ l’exécution peut reprendre à l'adresse de branchement
H
i : jmp 360
i+1
1
LI
2
DE
LI
3
CA
4
ER
susp susp
i+2
susp susp
i+3
susp
inst 360
5
LI
DE
CA
ER
Pénalité de 3 tops d’horloge !!!
Problème : - on a exécuté l'étape LI de i+1 inutilement
- l'étape LI est un accès mémoire donc coûteux
4. 33
Etapes d'exécution des instructions
Solution : branchement avec délai
jmp 360
i+1
LI
DE
CA
ER
LI
DE
CA
i+2
susp susp
i+3
susp
Toujours exécutée
ER
LI
DE
CA
ER
inst 360
• Si i est une instruction de saut, on exécute toujours l'intruction i+1
•Après décodage du jmp, on sait qu’il faut suspendre l’instruction i+2
→ pas d’étape LI inutile
• Le compilateur se charge de choisir l'instruction qu'il faut placer dans le délai
4. 34
Etapes d'exécution des instructions
Branchement avec délai : Optimisation de code
Objectif : remplir au mieux le pipeline tout en gardant la sémantique du programme
→ le compilateur « choisit » l’instruction à mettre derrière le branchement
→ réorganisation du code ou insertion de NOP (instruction "no operation")
Insertion de NOP
Instruction avant
ADD R1,R2,R3
jmp boucle
délai
ADD R1,R2,R3
jmp boucle
délai
ADD R1,R2,R3
jmp boucle
NOP
jmp boucle
ADD R1,R2,R3
4. 35
Généré par compilateur
Etapes d'exécution des instructions
Branchement avec délai: cas des branchements conditionnels (bcc)
on sait dans l’étage DE du bcc si le branchement doit être pris ou non
→ avec le délai, on n'a aucune suspension dans le cas où le branchement est pris
LI
Bcc 360
i+1
Toujours exécutée
bcc PRIS
bcc NON PRIS
DE
CA
ER
LI
DE
CA
ER
inst 360
susp
susp
LI
DE
LI
DE
CA
ER
Inst i + 2
4. 36
CA
ER
Etapes d'exécution des instructions
• Dans le cas des branchements conditionnels, pour savoir
quelle instruction mettre dans le délai, il faut “décider” si le
branchement sera pris ou non : c'est la prédiction de
branchement
• Une première prédiction est faite de façon statique (on
choisit d'office que le branchement est pris par exemple); le
compilateur tient compte de ce choix pour réorganiser le code
• Ensuite on corrige les prédictions de façon dynamique : la
partie contrôle change la prédiction si elle était mauvaise
4. 37
Etapes d'exécution des instructions
Branchement conditionnel avec délai: Optimisation de code
Prédiction STATIQUE
Instruction avant
Instruction cible
Instruction après
ADD R1,R2,R3
si R2 =0 alors
délai
MOV R0,R1
SUB R5,R6,R7
ADD R1,R2,R3
si R1 =0 alors
délai
MOV R0,R1
SUB R5,R6,R7
ADD R1,R2,R3
si R1 =0 alors
délai
MOV R0,R1
SUB R5,R6,R7
pas de dépendance entre inst. avant
et condition de test
si R2 =0 alors
ADD R1,R2,R3
MOV R0,R1
SUB R5,R6,R7
dépendance entre inst. avant et
condition de test.
spéculation branch pris
ADD R1,R2,R3
si R1 =0 alors
SUB R5,R6,R7
MOV R0,R1
SUB R5,R6,R7
4. 38
dépendance entre inst. avant et
condition de test.
spéculation branch non pris
ADD R1,R2,R3
si R1 =0 alors
MOV R0,R1
SUB R5,R6,R7
Etapes d'exécution des instructions
Prédiction de branchement DYNAMIQUE : (bas niveau, par la partie contrôle)
Pendant que le processeur travaille, l’unité de pré-extraction des instructions travaille
et lit les instructions qu’il faudra exécuter bientôt
→ prédiction spéculative du fait que le branchement courant sera pris ou pas.
Algorithme de Smith (prédiction à 2 bits):
pris
non pris
non pris
P
non pris
FP
pris
non pris
FNP
pris
P: Pris
FP: Faiblement Pris
NP
pris
FNP: Faiblement Non Pris
NP: Non Pris
4. 39
Etapes d'exécution des instructions
Pourquoi tant de mal?
•
Instructions de branchement : 20% des instructions d’un programme
•
Branchement conditionnel pris dans 60% des cas
•
Branchement pris
- des instructions ont été chargées dans le pipeline inutilement (il faut
stopper leur exécution)
- l’instruction peut ne pas être dans la file des instructions (ni dans le
cache d’instruction, ni dans la mémoire centrale) -> accès disque ->
coûteux !
•Branchements avec délais + optimisation de code :
dans les DSP (ex : téléphones portables)
•Dans les CPU actuels, la prédiction des branchements
permet d'anticiper l'exécution dans le désordre
4. 40
Etapes d'exécution des instructions
4. Une version pipeline de PROCSI: PIPSI
• Pipeline de 4 étages: LI (instruction fetch), DE (decode), EX (execute), EC
(écriture)
• Opérations arithmétiques/logiques : seulement modes registre/registre et
immédiat / registre
• Accès mémoire par instruction load/store en mode direct et indirect
• Toutes les instructions sont codées sur 2 mots de 16 bits
• Cache de données (1 cycle processeur)
• Cache d’instruction (1 cycle processeur)
• Le banc de registres internes (REG) permet 2 accès lecture et un accès
écriture simultanément (i.e sur un même top)
4. 41
Etapes d'exécution des instructions
FEtch
DEcode
EXecute
ECriture
RD1
RD2
Pcde
Pcex
IR
Irde
Irex
Cache
instruction
3
3
in
Ad-read1
Ad-read2
3
Cache
données
REG
Ad-write
4. 42
Adress
Data-in
PC
+2
Data-out
ROPex
Address
ROPde
out2
Data_high
ROP
out1
Data_low
resex
Etapes d'exécution des instructions
FE
accès mémoire inst.
1er mot dans ir
2ème mot dans rop
add R7, #1
DE
recherche
d'opérandes
FE
ir <- memi[pc]
DE
rd1 <- rop
rop <- memi[pc+1] rd2 <- reg[ir[0..2]]
pcde <- pc
pc <- pc + 2
irde <- ir
ropde <- rop
store [80], R0
EX
EC
calculs
écriture reg
lecture mém. data écriture mém. data
EX
resex <- rd1 + rd2
EC
reg[irex[0..2]] <- resex
pcex <- pcde
irex <- irde
ropex <- ropde
EX
DE
rd1 <- reg[ir[3..5]] resex <- rd1
pcex <- pcde
rop <- memi[pc+1] pcde <- pc
irde <- ir
irex <- irde
pc <- pc + 2
ropde <- rop
ropex <- ropde
FE
ir <- memi[pc]
4. 43
EC
memd[ropex] <- resex