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 des opérandes écriture des résultats
à l'adresse PC

lecture et
interprétation
des champs
d'instruction calculs

calcul de la nouvelle traitement des interruptions

valeur de PC matérielles (souris, clavier, ...)
(dépend du format de l'instruction) conditions d'erreur (division
par 0,overflow, ...), défaut de page

©W. Stallings « Computer Organization and Architecture »

4. 3
Etapes d'exécution des instructions

● Lecture d’instruction
• Charger le 1er mot d'instruction de la mémoire principale vers le registre d'instruction
● Décodage
• 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
• Accès aux registres (si mode registre)
• Calcul d’adresse et recherche d’opérandes mémoire (si mode mémoire)
● Exécution
• 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

SR REG CSreg
3

SP ROP PC IR

BUS
16

DATA_BUS
RAD
ADDRESS_BUS

AS
MEMOIRE DS
contrôle
R/W
instructions données

4. 5
Etapes d'exécution des instructions
Exemple de décomposition en étapes pour PROCSI

add R2, # 80 R2 <- R2 + 80

lecture instruction rad  pc lecture du code instruction
ir  mem[rad]
pc  pc + 1
décodage rad  pc lecture du 2ème mot d’instruction
rop  mem[rad] (constante 80)
pc pc + 1

recherche rd1  reg[ir(0..2)] ir(0..2) : bits 0, 1 et 2 de ir qui contiennent

opérande rd2  rop le code du registre destination
reg[ir(0..2)] est le registre destination
exécution rd1  rd1 + rd2

écriture reg[ir(0..2)]  rd1

résultat

4. 6
Etapes d'exécution des instructions
ADD R2, #80
RD1 RD2

R/Wreg
6
REG CSreg
SR
3

PC + 1
SP ROP PC IR

BUS
000000 0100X010
16

DATA_BUS
1) Lecture instruction
RAD
ADDRESS_BUS

AS
Légende :
MEMOIRE DS en 1er
PC:000000 0100X010
R/W
en 2ème
80
instructions données en 3ème

4. 7
Etapes d'exécution des instructions

RD1 RD2

R/Wreg
6
REG CSreg
SR
3

80 PC + 1
SP ROP PC IR

000000 0100X010
BUS

16

2) décodage
RAD DATA_BUS
ADDRESS_BUS

AS

MEMOIRE DS
PC :000000 0100X010
80 R/W
instructions données

4. 8
Etapes d'exécution des instructions
6 80
RD1 RD2

R/Wreg
010 6
REG CSreg
SR
3

SP ROP PC IR
000000 0100X010
BUS

16

3) recherche opérande
RAD 17 DATA_BUS
ADDRESS_BUS

AS

MEMOIRE DS

000000 0100X010 R/W

instructions données
80

4. 9
Etapes d'exécution des instructions
86
RD1 6 RD2 80

R/Wreg
6
REG CSreg
SR
+ 3

SP ROP PC IR

BUS

16

DATA_BUS
RAD 17 4) Exécution
ADDRESS_BUS

AS

MEMOIRE DS

000000 0100X010 R/W

instructions données
80

4. 10
Etapes d'exécution des instructions

RD1 RD2
86
R/Wreg
86 6
010 REG
SR CSreg
3

SP ROP PC IR

BUS

16

5) Ecriture résultat
RAD 17 DATA_BUS
ADDRESS_BUS

AS

MEMOIRE DS

000000 0100X010 R/W

instructions données
80

4. 11
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 contient 80

rop  mem[rad]
pc pc + 1

recherche opérande rd1  reg[ir(3..5)] ir(3..5) : bits 3, 4 et 5 de ir qui contiennent

rad  rop le numéro du registre source
rd2  mem[rad] reg[ir(3..5)] est le registre source (R3 ici)
rd2 contient MEM[80]
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 AVEC PIPELINE

8 ns 8 ns 8 ns 8 ns
2 2 2 2 2 2 2 2 2 2 2 2 24 ns i: 2 2 2 2
i i+1 i+2
i+1: 2 2 2 2

i+2: 2 2 2 2 12 ns

4. 14
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: 1 1 1 1
i+1: 1 1 1 1

i+2: 1 1 1 1
4. 15
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 cmp eax, ebx
bnez suite cmovz ecx, edx
mov 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 DE CA ER

i+1: LI DE CA ER Top d’horloge

LI DE CA ER
i+2:
LI DE CA ER
i+3:
1 2 3 4 5 6 7

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»

LI DE CA ER

ALU
PC

Inst Données
Registres R1=10
Mémoire R2=8
R3=0
R4=6
R5=3
4. 21
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 1

LI DE CA ER

R2
add R2,R1,R2

R1
R2
Add

ALU
PC

Inst Données
Registres R1=10
Mémoire R2=8
R3=0
R4=6
R5=3
4. 22
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 2

LI DE CA ER

R5

8
add R3,R4,R5

R4
accès à R1

10
et R2

R2
R3

Add
Add

ALU
PC

Inst Données
Registres R1=10
Mémoire R2=8
R3=0
R4=6
R5=3
4. 23
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 3

LI DE CA ER

18
3
10 + 8

R2
accès à R4

6
et R5

R3

Add
Add
ALU
PC

Inst Données
Registres R1=10
Mémoire R2=8
R3=0
R4=6
R5=3
4. 24
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5» TOP 4

LI DE CA ER

9
6+3 accès à R2

R3
Add
ALU
PC

Inst Données
Registres R1=10
Mémoire R2=8 18
R3=0
R4=6
R5=3
4. 25
Etapes d'exécution des instructions
Exécution de «add R2,R1,R2» suivi de «add R3,R4,R5»
TOP 5

LI DE CA ER

accès à R3

ALU
PC

Inst Données
Registres R1=10
Mémoire R2=18
R3=0 9
R4=6
R5=3
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 Ecriture de R1

instruction Aléa de type « lecture avant écriture »

ADD LI DE CA ER
SUB LI DE 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 Ecriture de R1

ADD LI DE CA ER
SUB LI DE CA ER
lecture de R1
Ecriture de R1

ADD LI DE CA ER
SUB LI susp susp DE CA ER

lecture de R1

4. 29
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.

LI DE CA ER

3
8
8+0
accès à R1

8
R6
et R5

R1
Add ALU
PC

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 LI DE
i+1 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 1 2 3 4 5
i : jmp 360 LI DE CA ER
i+1 LI susp susp
i+2 susp susp

i+3 susp

inst 360 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 LI DE CA ER

i+1 LI DE CA ER Toujours exécutée

i+2 susp susp

i+3 susp 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 ADD R1,R2,R3
jmp boucle jmp boucle
délai délai

ADD R1,R2,R3
jmp boucle jmp boucle
NOP ADD R1,R2,R3 Généré par compilateur

4. 35
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

Bcc 360 LI DE CA ER

i+1 Toujours exécutée LI DE CA ER inst 360

bcc PRIS susp susp LI DE CA ER
LI DE CA ER
bcc NON PRIS
Inst i + 2

4. 36
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 ADD R1,R2,R3 ADD R1,R2,R3
si R2 =0 alors si R1 =0 alors si R1 =0 alors
délai délai délai
MOV R0,R1 MOV R0,R1 MOV R0,R1
SUB R5,R6,R7 SUB R5,R6,R7 SUB R5,R6,R7

pas de dépendance entre inst. avant dépendance entre inst. avant et dépendance entre inst. avant et
et condition de test condition de test. condition de test.
spéculation branch pris spéculation branch non pris

ADD R1,R2,R3 ADD R1,R2,R3

si R2 =0 alors si R1 =0 alors si R1 =0 alors
ADD R1,R2,R3 SUB R5,R6,R7 MOV R0,R1
MOV R0,R1 MOV R0,R1
SUB R5,R6,R7 SUB R5,R6,R7
SUB R5,R6,R7

4. 38
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 non pris non pris

P FP FNP NP

pris pris pris

P: Pris FNP: Faiblement Non Pris

FP: Faiblement 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
resex

ROP ROPde ROPex

PC Pcde Pcex
+2
Irde Irex

Data-out
IR

Data-in
Data_high
Data_low

Adress
out2
out1
Address

3
3 in 3
Ad-read1 Cache
Cache REG
Ad-read2 données
instruction
Ad-write

4. 42
Etapes d'exécution des instructions

FE DE EX EC
accès mémoire inst. recherche calculs écriture reg
1er mot dans ir d'opérandes lecture mém. data écriture mém. data
2ème mot dans rop

add R7, #1 FE DE EX EC
ir <- memi[pc] rd1 <- rop resex <- rd1 + rd2 reg[irex[0..2]] <- resex
rop <- memi[pc+1] rd2 <- reg[ir[0..2]] pcex <- pcde
pcde <- pc
pc <- pc + 2 irex <- irde
irde <- ir
ropex <- ropde
ropde <- rop

store [80], R0 FE DE EX EC
ir <- memi[pc] rd1 <- reg[ir[3..5]] resex <- rd1 memd[ropex] <- resex
rop <- memi[pc+1] pcde <- pc pcex <- pcde
pc <- pc + 2 irde <- ir irex <- irde
ropde <- rop ropex <- ropde

4. 43