Introduction au pipelining

ARCHITECTURE • Pipelining: recouvrement de l’exécution de

plusieurs instructions (travail à la chaîne)
A2- 07/08
A B C D
• Analogie à une laverie
Léon Mugwaneza – A, B, C, et D ont chacun un
ESIL/Dépt. Informatique (bureau A118) sac d’habits à laver, sécher,
mugwaneza@univmed.fr
et plier
– Laver prend 30 minutes
3. Pipelining: notions de base – Sécher prend 40 minutes
– “Plier” prend 20 minutes

Laverie pipelinée
Laverie séquentielle
• Commencer une tâche dès que possible
18 19 20 21 22 23 Minuit
18h 19 20 21 22 23 Minuit
temps
O O Temps
r r
30 40 20 30 40 20 30 40 20 30 40 20
d d
r r
30 40 40 40 40 20
e
A e
A
des des
B
T T B
â C â
c c
h h
C
e D e
s s D
• Laver séquentiellement prend 6 heures pour 4 tâches
• Combien de temps ça leur aurait pris s’ils avaient appris le • La laverie pipelinée prend 3.5 heures pour les 4 tâches
pipelining? • Facteur d’accélération (Speedup) = 6/3.5 = 1.7

1
 « Enseignements » du pipelining DLX : une machine RISC «typique»
• Un format fixe de 32 bits par instruction (3 formats)
• plusieurs tâches • 32 registres généraux de 32 bits (R0 contient zéro)
18h 19 20 21 s’exécutent simultanément • 32 registres FP de 32 bits (utilisés par paires en DP)
Temps en utilisant des ressources
O différentes • Machine Load/Store
r
• le Pipelining n’améliore pas • 3-adresses (registres adressables), les instructions
d 30 40 40 40 40 20 la latence d’une seule
r tâche, mais le débit
arithmétiques sont reg-reg
e A • l’accélération est limitée • Un mode d’adressage unique: base + déplacement
par l’étage le plus lent – pas d’indirection
des
• speedup potentiel= nombre
B d’étages dans le pipe • Conditions de branchement simples
T
â
• étages de «longueurs» ≠ • (Branchement différé)
C ⇒ speedup réduit
c
h • le temps de “remplissage” Voir : SPARC, MIPS, HP PA-Risc, DEC Alpha, IBM PowerPC,
e et le temps de “vidage” CDC 6600, CDC 7600, Cray-1, Cray-2, Cray-3
s
D réduisent le speedup
• Jeu d’instructions très semblable à celui du MIPS R2000
(cf. Logiciel de Base - 1ère année)

DLX : codage des instructions Cycle “Fetch Decode Execute”

Instruction Rechercher (lire) l’instruction en mémoire
Register-Register
Fetch
31 26 25 21 20 16 15 11 10 6 5 0

Op Rs1 Rs2 Rd Opx R Instruction Déterminer de l’opération et de la taille de

Register-Immediate
Decode l’instruction
31 26 25 21 20 16 15 0
immediate I Operand
Op Rs1 Rd Recherche des opérandes
Fetch
Branch
31 26 25 21 20 16 15 0
I Execute “Exécution”
Op Rs1 Rs2/Opx immediate

Jump / Call Result

Ranger les résultats
31 26 25 0 Store
Op target J
Next
Déterminer la prochaine instruction
Instruction

2
 Implantation du DLX :
Une implantation du DLX un chemin de données
• La plupart des instructions du DLX sont interprétées en 5 Instruction Instr. Decode Execute Memory Write
cycles d’horloge Fetch Reg. Fetch Addr. Calc Access Back
Next PC
• Les deux premiers cycles sont les mêmes pour toutes les

MUX
instructions Next SEQ PC

Adder
1.Instruction fetch cycle (IF)
4 RS1
Zero?

IR ← Mem [PC] (load instruction)

MUX MUX
RS2

Address

Memory

Reg File
NPC ← PC+4 (update program counter)

Ins

ALU
t
L

Memory
2.Instruction decode / register fetch cycle (ID) RD

Data
M

MUX
A ← Regs[IR 6..10 ] (fetch source reg1)
D
B ← Regs[IR 11..15 ] (fetch source reg2) Sign
Imm Extend
Imm ← (IR 16 )16 ## IR 16..31 (fetch and sign-ext imm.)
(où ## est la concaténation de chaîne de bits)
WB Data

 IR0 est le bit de poids forts de IR et IR31 le bit de poids faibles

DLX : exécution en plusieurs cycles DLX : exécution en plusieurs cycles

(Cycle 3) (Cycle 4)
• Cycle 3 : exécution/ calcul de l’adresse effective (EX)
• Les actions dépendent du type des opérations • Cycle 4 : Accès mémoire / fin inst. Branchement (MEM)
– Memory reference (e.g., LW R1, 30 (R2)) • Les seules instructions actives sont les loads, les stores, et
branchements
ALUOutput ← A + Imm (Calculate effective address)
– Loads (e.g., LW R1, 30 (R2))
– Register-Register ALU op. (e.g., ADD R1, R2, R3) LMD ← Mem[ALUOutput] (load memory onto processor)
ALUOutput ← A op B (Perform ALU operation) – Stores (e.g., 500(R4), R3)
– Register-Immed. ALU op. (e.g., ADDI R1, R2, 36) Mem[ALUOutput] ← B (store data into memory)
ALUOutput ← A op Imm (Perform ALU operation) – Branches (e.g., BEQZ R4, next)
if (cond) PC ← ALUoutput (Set PC based on cond)
– Branch (e.g., BEQZ R4, next)
else PC ← NPC
ALUOutput ← NPC + Imm (Compute branch target)
Cond ← (A == 0) (Compare A to 0)

3
 DLX : exécution en plusieurs cycles CPI pour l’implantation du DLX
(Cycle 5)
• Cinquième cycle : écriture des registres (WB)
• Les résultats sont écrits dans les registres • L’implantation du DLX ci-dessus met 4 cycles pour
– Register-Register ALU op. (e.g., ADD R1, R2, R3) les branchements et les stores et 5 cycles pour les
Regs[IR16..20] ← ALUOutput autres opérations
– Register-Immed. ALU op (e.g., ADDI R1, R2, 36) – Si 20% des instructions sont des branchements
ou des stores, on a un CPI de 4,80
Regs[IR11..15] ← ALUOutput
• On pourrait améliorer le CPI en réalisant les
– Load Instruction (e.g., LW R1, 30 (R2)) opérations ALU en 4 cycles
Regs[IR11..15] ← LMD – Si 40% des instructions étaient des opérations
ALU, le CPI serait réduit à 4,40

DLX : Implantation pipelinée DLX pipeliné : chemin de données

Instruction Instr. Decode Execute Memory Write
Fetch Reg. Fetch Addr. Calc Access Back
• Pour réduire le CPI, le DLX peut être implanté en Next PC

MUX
Next SEQ PC Next SEQ PC
utilisant un pipeline à 5 étages

Adder
Inst. CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9
4 RS1
Zero?

MUX MUX

MEM/WB
Address

Memory
1 IF ID EX MEM WB

EX/MEM
RS2

Reg File

ID/EX
IF/ID

ALU

Memory
2 IF ID EX MEM WB

Data

MUX
3 IF ID EX MEM WB

WB Data
Sign
4 IF ID EX MEM WB Imm Extend

5 IF ID EX MEM WB RD RD RD

• Dans cet exemple, on met 9 cycles pour 5

instructions, ie un CPI de 1,8 • Des registres sont utilisés pour stocker les résultats entre deux
étages successives
 Le temps d’exécution d’une instruction est rallongé

4
 Visualiser le pipeline (1/2) Visualiser le pipeline (2/2)
Time (clock cycles)
Time (clock cycles)
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 CC 1 CC 3 CC 4
CC 2
I

Ifetch

Ifetch

Ifetch

Ifetch
ALU
Ifetch Reg DMem Reg
n
Add R1,R2,R3 Lw R4,0(R2) Sub R6,R5,R7 Xor R9,R8,R1
s
t

Reg
Reg

Reg
Reg
ALU
Ifetch Reg DMem Reg
r. Nop Add R1,R2,R3 Lw R4,0(R2) Sub R6,R5,R7

O ALU ALU ALU

ALU
Reg ALU
Ifetch Reg DMem

r Nop Nop Add R1,R2,R3 Lw R4,0(R2)

d

DMem
DMem

DMem

DMem
ALU
Ifetch Reg DMem Reg
e
Nop Nop Nop Add R1,R2,R3
r

Reg
Reg

Speedup du Pipeline : exemple
• Supposons que le DLX non pipeliné a un cycle d’horloge de 10
ns, les loads prennent 5 cycles et font 40% des instructions,
et toutes les autres instructions prennent 4 cycles
• Si le pipelining ajoute 1 ns au cycle d’horloge, quel est le
speedup dû au pipelining ?
Séquentiel : Ave Instr. Time = Clock cycle x Average CPI
= 10 ns x (0.6 x 4 + 0.4 x 5)
= 44 ns
Pipeliné : Ave Instr. Time = 10 + 1 = 11 ns
Speedup = 44 / 11 = 4
Reg
Reg
Le pipelining n’est pas si simple
• Limites du pipelining : des aléas (pipeline hazards en anglais)
ou empêchent l’exécution d’une nouvelle instruction à chaque
cycle
– aléas structurels : le matériel ne peut pas exécuter les
instructions en même temps (conflit de ressources)
– aléas de données : une instruction dépend du résultat d’une
instruction précédente encore dans le pipeline
– aléas de contrôle : dûs au pipelining des branchements et
autres instructions qui changent PC
• Solution classique : bloquer (stall) le pipeline jusqu’à
«résolution» de l’aléa, en insérant une ou plusieurs “bulles”
dans le pipeline (instruction transformée en NOP)

Ceci ne tient pas compte du temps pour remplir et vider le On utilise aussi le terme dépendance (dépendance structurelle,
pipeline et des blocages du pipeline dépendance de données, dépendance de contrôle)

5
 Aléas de données Aléas structurels: accès à la mémoire (1/2)
Time (clock cycles) Time (clock cycles)
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
IF ID/RF EX MEM WB

ALU
I I Load Ifetch Reg DMem Reg

ALU
add r1,r2,r3 Ifetch Reg DMem Reg

n n
s s Instr 1

ALU
Ifetch Reg DMem Reg

ALU
Ifetch Reg DMem Reg
t sub r4,r1,r3 t
r. r. Instr 2

ALU
Ifetch Reg DMem Reg

ALU
Reg
and r6,r1,r7 Ifetch Reg DMem

O O

ALU
Instr 3 Ifetch Reg DMem Reg

r r

ALU
Ifetch Reg DMem Reg
or r8,r1,r9
d d

ALU
e e Instr 4 Ifetch Reg DMem Reg

ALU
r xor r10,r1,r11 Ifetch Reg DMem Reg
r

Aléas structurels: accès à la mémoire (2/2) Aléas et speedup dû au pipelining (1/2)

Time (clock cycles)
• Les aléas réduisent le facteur d’accélération dû au
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
pipelining
ALU

I Load Ifetch Reg DMem Reg

Ave Instr Time unpipelined

n Speedup from pipelining =
Ave Instr Time pipelined
s Instr 1
ALU

Ifetch Reg DMem Reg

CPIunpipelined x Clock Cycleunpipelined
t =
CPIpipelined x Clock Cyclepipelined
r. Instr 2
ALU

Ifetch Reg DMem Reg

CPIpipelined = Ideal CPI + Pipeline stall CPI

O = 1 + Pipeline stall CPI
Stall Bubble Bubble Bubble Bubble Bubble
r
d Speedup = CPIunpipelined
xClock Cycleunpipelined
ALU

e Instr 3 Ifetch Reg DMem Reg

1 + Pipeline stall CPI Clock Cyclepipelined
r Pipeline depth
Speedup <
1 + Pipeline stall CPI

6
 Aléas et speedup dû au pipelining (2/2)
exemple Aléas Structurels
• Une machine A a une mémoire double ports permettant l’accès
simultanée aux instructions et données
• Une machine B a, elle, une mémoire simple port, mais son • Aléa structurel quand 2 ou plusieurs instructions ont
implantation pipelinée a un temps de cycle 1,05 x plus petit besoin de la même ressource
• CPI idéal = 1 pour les deux
• Autres solutions que bloquer les instructions ?
• 40% des instructions exécutées font des refs à la mémoire pour
accéder aux données – dupliquer la ressource
Ave Instr.Time A = Clock cycle A x CPI A – pipeliner la ressource
= Clock cycle A – réordonner les instructions
Ave Instr.Time B = Clock cycle B x CPI B
= (Clock cycle A / 1.05) x (1 + 0.4) • Le coût de l’élimination de certains aléas structurels
= Clock cyle A x 1.33 peut être prohibitif : dans ce cas le pipeline doit être
Ave Instr.Time B
= 1.33
bloqué en attendant que la ressource soit libérée
Ave Instr.Time A (pipeline stall)

 La machine A est 1,33 fois plus rapide

Aléas de données Trois types d’aléas de données (1/3)

Time (clock cycles)

IF ID/RF EX MEM WB 1. Aléas RAW

I
ALU

add r1,r2,r3 Ifetch Reg DMem Reg

n InstrI suivie par InstrJ

s
ALU

Reg
t sub r4,r1,r3 Ifetch Reg DMem
• Read After Write (RAW)
r. InstrJ essaie de lire l’opérande avant que InstrI ne
l’écrive
ALU

and r6,r1,r7 Ifetch Reg DMem Reg

O – Instr i: add r1,r2,r3 (écrit r1 après)

----------------------
r
ALU

Ifetch Reg DMem Reg

or r8,r1,r9 – Instr j: sub r4,r1,r5 (lit r1 avant )
d
e • Réordonner les instructions peut réduire ou éliminer
ALU

r xor r10,r1,r11 Ifetch Reg DMem Reg

les aléas de données de type RAW

Autres solutions que bloquer les instructions ?

7
 Trois types d’aléas de données (2/3) Trois types d’aléas de données (3/3)
2. Aléas WAR 3. Aléas WAW
InstrI suivie par InstrJ InstrI suivie par InstrJ
• Write After Read (WAR) : InstrJ essaie d’écrire l’opérande • Write After Write (WAW) : InstrJ essaie d’écrire l’opérande
avant que InstrI n’ait pu le lire avant que InstrI n’ait pu l’écrire
– Instr i: add r1,r2,r3 (lit r2 après) – Instr i: add r1, r2, r3 (écrit r1 après)
---------------------- ----------------------
– Instr j: sub r2, r4, r5 (écrit r2 avant) – Instr j: sub r1, r4, r5 (écrit r1 avant)
• Ne peuvent pas se produire dans le pipeline à 5 étages du • Ne peuvent pas se produire dans le pipeline à 5 étages du
DLX car : DLX car :
– toutes les instructions passent dans les 5 étages dans l’ordre – toutes les instructions passent dans les 5 étages, et
– les lectures sont faites à l’étage 2 et les écritures à l’étage 5 – les écritures sont faites à l’étage 5

• Peuvent se produire si les instructions ne sont pas • Peuvent se produire si les instructions ne prennent pas le
lancées dans l’ordre ou si les lectures sont effectuées même temps
plus tard • Les aléas WAR et WAW seront étudiés plus tard dans
des pipelines «complexes»

Forwarding pour éliminer les aléas de Forwarding pour éliminer les aléas de
données RAW (1/2) données RAW (2/2)
Time (clock cycles) Time (clock cycles)
IF ID/RF EX MEM WB I
n add r1,r2,r3

ALU
Ifetch Reg DMem Reg
I
ALU

add r1,r2,r3 Ifetch Reg DMem Reg

s
n t
sub r4,r1,r3

ALU
s Ifetch Reg DMem Reg
r.
ALU

Reg
t sub r4,r1,r3 Ifetch Reg DMem

r. O

ALU
Ifetch Reg DMem Reg
and r6,r1,r7
r
ALU

and r6,r1,r7 Ifetch Reg DMem Reg

O d

ALU
r e or r8,r1,r9
Ifetch Reg DMem Reg
ALU

Ifetch Reg DMem Reg

or r8,r1,r9 r
d
e

ALU
Ifetch Reg DMem Reg
xor r10,r1,r11
ALU

r
xor r10,r1,r11 Ifetch Reg DMem Reg

 On récupère le résultat de l’instruction dès qu’il est prêt sans attendre l’écriture
Peut-on utiliser la valeur de r1 avant qu’elle ne soit écrite dansregistre ? dans le registre. On parle aussi de «court-circuitage» (bypassing, short-circuiting)

8
 «Matériel» pour le forwarding Aléas de données RAW malgré
le forwarding (1/2)
Time (clock cycles)

NextPC
lw r1, 0(r2)

ALU
I Ifetch Reg DMem Reg

mux
n
Registers

EX/MEM

MEM/WR
ALU

ALU
ID/EX

t
sub r4,r1,r6 Ifetch Reg DMem Reg

Data
mux r.
Memory

ALU
Ifetch Reg DMem Reg
and r6,r1,r7

mux
Immediate
O
r

ALU
d or r8,r1,r9 Ifetch Reg DMem Reg

e
r

Aléas de données RAW malgré Réordonnancement des instructions pour

le forwarding (2/2) Time (clock cycles) masquer les délais de chargement
I
n Soit à générer un code pour:
lw r1, 0(r2)
ALU

Ifetch Reg DMem Reg

s
t a = b + c;
r. d = e – f;
ALU

sub r4,r1,r6 Ifetch Reg stall DMem Reg

en supposant a, b, c, d ,e, et f en mémoire.

O
r stall
ALU

Ifetch Reg DMem Reg

and r6,r1,r7 Code «rapide » :
d Code « lent » :
LW Rb,b
e LW Rb,b
ALU

stall Ifetch Reg DMem LW Rc,c

r or LW Rc,c
(Stall) ADD Ra,Rb,Rc LW Re,e
r8,r1,r9 ADD Ra,Rb,Rc
SW a,Ra
 Délai de chargement (Load delay) LW Re,e LW Rf,f
SW a,Ra
 Si le matériel ne bloque pas l’instruction sub, le résultat LW Rf,f
SUB Rd,Re,Rf
sera faux : on parle de chargement différé (le (Stall) SUB Rd,Re,Rf
SW d,Rd SW d,Rd
programmeur devra insérer des instructions NOP)

9
 Compilateurs et délais de chargement Aléas de contrôle dans le DLX
• Les aléas de contrôle sont dûs aux instructions qui
ordonnancés non ordonnancés modifient PC
• Un branchement est :
gcc 54% – soit Pris (Taken) : PC ← PC + 4 + Imm
31%
– soit Non Pris (Not Taken) : PC ← PC + 4
spice 42%
14% • La solution la plus simple est de bloquer le
65%
pipeline dès que l’on détecte une instruction de
tex branchement
25%
– détection des branchements dans ID
0% 20% 40% 60% 80% – évaluation de la condition de branchement dans mem
% loads qui bloquent le pipeline  Si le branchement est Pris, on doit refaire les
étages IF et ID
 Les compilateurs réduisent le nombre de blocages dûs  Les aléas de contrôle peuvent conduire à des
aux instructions de chargement mais ne peuvent pas les dégradations importantes des performances
éliminer complètement

Aléas de contrôle dans le DLX Délai dû aux aléas de contrôle

Instruction Instr. Decode Execute Memory Write
Fetch Reg. Fetch Addr. Calc Access Back • Les aléas de contrôle sur le DLX entraînent une
Next PC suspension du pipeline de 3 cycles. Si le
MUX

Next SEQ PC Next SEQ PC

branchement est pris, la nouvelle instruction doit
Adder

être lue et décodée

4 RS1
Zero?

Inst. CC1 CC2 CC3 CC4 CC5 CC6 CC7 CC8 CC9
MUX MUX

MEM/WB
Address

Memory

EX/MEM

RS2
Reg File

ID/EX
IF/ID

ALU

Memory

Branch IF ID EX MEM WB
Data

MUX

Branch+1 IF Stall Stall IF ID EX MEM WB

WB Data

Sign
Imm Extend
• Si le branchement n’est pas pris, l’instruction
RD RD RD
peut continuer dans l’étage ID

10
 Impact des aléas de contrôle - exemple DLX pipeliné : chemin de données modifié
Instruction Instr. Decode Execute Memory Write
Fetch Reg. Fetch Addr. Calc Access Back
• Si CPI = 1, 30% de branchements, suspension de 3 cycles Next PC Next
=> nouveau CPI = 1.9!

MUX
SEQ PC

Adder
Adder
• Solution :
Zero?
– évaluer la condition de branchement le plus tôt possible, ET 4 RS1

MEM/WB
Address

Memory

EX/MEM
RS2
– calculer l’adresse de branchement plus tôt

Reg File

ID/EX

ALU
IF/ID

Memory
• Les branchements du DLX testent si registre = 0 ou ≠ 0

MUX

Data

MUX
• Une solution pour le DLX :
– réaliser le test dans l’étage ID

WB Data
Sign
Imm Extend

– ajouter un additionneur pour calculer new PC à l’étage ID

RD RD RD

⇒ 1 cycle de pénalité au lieu de 3

Quatre alternatives pour résoudre les

Instructions de branchement dans
les programmes
• Etude des benchmarks SPEC sur le DLX
– fréquence de 14% à 16% dans les programmes sur
les entiers, et de 3 % à 12% dans les programmes
sur les flottants
– près de 75% des branchements sont des
branchements en avant
– 60% des branchements en avant sont pris
– 80% des branchement en arrière sont pris
– 67% de tous les branchements sont pris
aléas de contrôle (1/2)
#1 : Suspendre le pipeline jusqu’à l’évaluation de la condition de
branchement
#2 : Prédire le branchement comme «non pris» (not taken)
– exécuter les instructions suivantes
– “purger” les instructions du pipeline si le branchement est finalement pris
– l’état du processeur ne doit pas être modifié avant de savoir si le
branchement n’est pas pris
– en moyenne 33% des branchements dans les programmes ne sont pas pris
– PC+4 est déjà calculé pour l’instruction suivante
#3 : Prédire le branchement comme «pris» (taken)
– en moyenne 67% des branchements dans les programmes sont pris
– Mais, dans notre DLX on ne peut pas calculer l’adresse de branchement
avant ID (en même temps que la la condition de branchement)
» le DLX a encore 1 cycle de suspension
» sur d’autres machines l’adresse de branchement peut être connue avant
l’évaluation de la condition de branchement

11
 Quatre alternatives pour résoudre les Ordonnancement des délais des
aléas de contrôle (2/2) branchements différés
#4: Branchement Différé (Delayed Branch)
• Où trouver les instructions pour «remplir» le «délai»?
– Le branchement est effectué APRES qqs instructions suivantes (qui
s’exécutent jusqu’au bout) – avant l’instruction de branchement
– à l’adresse de branchement (target instruction) : intéressant si branchement
branch instruction pris
sequential successor1 – après l’instruction de branchement (fall through) : intéressant si branchement
sequential successor2 non pris
Délai de branchement
........ (Branch delay of length n) – NOPs
sequential successorn – cancelling branches (l’instruction de branchement inclut la prédiction et si
branch target if taken celle-ci s’avère être fausse, les instructions dans le délai de branchement sont
transformées en NOP - voir plus loin)

– 1 délai de 1 cycle si évaluation de la condition de • Efficacité des compilateurs sur un délai de branchement de 1
branchement et calcul de l’adresse de branchement cycle :
– les compilateurs ordonnancent ≈ 60% des délais de branchement
à l’étage ID dans le pipeline du DLX à 5 étages ci-
– ≈ 80% des instructions dans les délais de branchements font un calcul utile
dessus
⇒ ≈ 50% (60% x 80%) des délais sont donc utilement «remplis»
Solution adoptée dans le DLX ( … pour l’instant !)

Prédiction «statique» des Pipelining : complications (1/4)

branchements (par le compilateur)
• Comparaison de deux stratégies • Exceptions : événements autres que les instructions de
– direction-based : branchement en arrière prédits Pris, et branchement en branchement qui changent le cours «normal» de l’exécution
avant Non Pris des instructions
– profile-based : prédiction basée sur le profiling du programme (mesures
collectées sur les exécutions antérieures) • 5 instructions en exécution dans 5 étages du pipeline
100000 – comment arrêter le pipeline?
10000
– comment redémarrer le pipeline?
Instructions between Profile-based
mispredictions – origine de l’exception?
1000 Direction-based
Etage Type d’exception
100 IF Défaut de page; pb. alignement, violation de protection
10 ID opcode non définie ou illégal
EX Erreur (déroutement)
1
tomcatv
doduc

MEM Défaut de page; pb. alignement, violation de protection

compress

espresso

hydro2d

swm256
gcc

mdljsp2

ora
alvinn

12
 Pipelining : complications (2/4)
• Exceptions simultanées dans plusieurs étages du
Pipelining : complications (3/4)
pipeline, exemple :
– load avec un défaut de page dans MEM • Notre DLX pipeliné écrit les résultats à la fin de l’exécution de
– add avec un défaut de page dans IF l’instruction. Tous les processeurs ne procèdent pas ainsi :
– l’exception de add surviendra AVANT celle dûe à load, même  Modes d’adressage : l’auto-incrémentation change le registre
si l’instruction load est placée avant pendant l’exécution de l’instruction
– si Exceptions, il faut restaurer la valeur du registre avant modification
• Solution #1 – possibilité d’aléas WAR et WAW car l’écriture ne se fait plus seulement au
– un vecteur Etat des exceptions par instruction dernier étage
– différer la prise en compte des exceptions au dernier étage,  Instructions de transfert Mémoire-Mémoire
et défaire les modifications sur l’état du processeur si – il faut pouvoir traiter plusieurs défauts de page dans une instruction
exception – le VAX et les x86 stockent les valeurs temporairement dans des registres
• Solution #2  Codes conditions
– arrêter le pipeline ASAP – il faut pouvoir connaître la dernière instruction qui a modifié le code condition
– redémarrer toutes les instructions qui n’ont pas terminé
⇒ Plus facile si l’état du processeur est modifié le
plus tard possible

Pipelining : complications (4/4) # Résumé : notions de base du pipelining

• Les Instructions FP • Le Pipelining permet le recouvrement de l’exécution de plusieurs
instructions
– prennent plus de temps que les instructions INT
• Idéalement, le CPI est de 1, et le speedup est égal au nombre d ’étages
– plusieurs unités FP qui fonctionnent en parallèle
du pipeline
– les unités fonctionnelles FP peuvent être pipelinées pour pouvoir
commencer une nouvelle instruction par cycle • Le pipelining améliore le «débit» et non le temps d’exécution d’une
instruction
– aléas WAR et WAW car les instructions ne prennent plus le même
temps (ex : FPSQR 30 fois plus lent que FPADD) • Les aléas limitent les performances
FP Instruction Exec Time Initiation Rate (MIPS R4000) • Solutions aux aléas :
– structurels : plus de ressources HW
Add, Subtract 4 3
– données : forwarding, réordonnancement par le compilateur
Multiply 8 4 – contrôle : Evaluation rapide de la condition de branchement & PC,
Divide 36 35 branchement différé, prédiction

Square root 112 111 • Augmenter le nb. d’étages accentue l’effet des aléas
Negate 2 1 • Les exceptions, les instructions FP, l’ISA compliquent le pipelining
Absolute value 2 1 • Le compilateur réduit l’effet des aléas de données et de contrôle
– en remplissant les délais de chargement (load delay scheduling)
FP compare 3 2
– en remplissant les délais de branchement (branch delay scheduling)
Cycles before Cycles before issue – en essayant de prédire les branchements
use result instr of same type

13