Chap7 Pipeline

Notion de Pipeline
Exemple: Opération de lavage du linge
4 personnes ; chacun doit :

laver, sécher, repasser, ranger A B C D
lavage : 30 minutes
séchage : 40 minutes
Repassage : 30 minutes
Rangement : 20 minutes
NHA/MMY Pipeline Based on UCB Page : 1

Lavage du linge en séquentiel
6 PM 7 8 9 10 11 12 1 2 AM
O 30 40 30 20 30 40 30 20 30 40 30 20 30 40 30 20
r Time
A
d
r B
e C
T D
â
c
h ° 8 heures pour terminer
e
s
Lavage linge en pipeline
6 PM 7 8 9 10 1
O Temps
1
r
d 30 40 40 40 40 30 20
r A
e
B
T C
â D
c
h
e
s
° 4 heures !

Remarques sur le traitement en pipeline
° Traitement en pipeline n ’améliore pas le temps de

chaque tâche, mais le débit des opérations
° Tâches multiples en parallèles avec ressources
différentes
° Gain de temps = Nombre d ’étages
° Débit de pipeline est limité par l ’étage le plus lent
° Longueur non-équilibrée réduit le gain de temps
° Temps pour « remplir » et « décharger » pipeline
réduit le gain de temps

5 Etages pour Chargement (LW)
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5
LW Ifetch Reg/Dec Exec Mem Wr
° Ifetch: Fetch de l ’instruction

° Reg/Dec: Fetch des registres et décodage instruction
° Exec: Calculer l ’adresse mémoire
° Mem: Lecture de mémoire données
° Wr: Ecriture dans les registres
° Chemin données : Insertion d ’autres registres

intermédiaires (entre étages) pour permettre
traitement pipeline
Représentation d’exécution en pipeline
Temps
IFetch Dcd Exec Mem WB

Déroulement du programme

Comparaison: 1-Cycle, Multi-Cycle, Pipeline
Cycle 1 Cycle 2
Clk
Implémentation 1-Cycle:
LW SW Perte
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9 Cycle 10
Clk
Implémentation Multi-Cycle:
LW SW R-type
Ifetch Reg Exec Mem Wr Ifetch Reg Exec Mem Ifetch
Implementation Pipeline:
LW Ifetch Reg Exec Mem Wr
SW Ifetch Reg Exec Mem Wr
R-type Ifetch Reg Exec Mem Wr

Pourquoi le pipeline?
° Exécution de 100 instructions

° Machine 1-Cycle
• 45 ns/cycle x 1 CPI x 100 inst = 4500 ns
° Machine Multi-Cycle
• 10 ns/cycle x 4.4 CPI (mixte d ’instructions) x 100 inst = 4400 ns
° Machine en Pipeline
• 10 ns/cycle x (1 CPI x 100 inst + 4 cycles décharg.) = 1040 ns

Ressources Disponibles!
Temps (cycles)
O
r
d
r
ALU
Im Reg Dm Reg
e Inst 0
ALU
I
n
Inst 1 Im Reg Dm Reg
ALU
t Inst 2 Im Reg Dm Reg
r
u Inst 3
ALU
c Im Reg Dm Reg
t
i Inst 4
ALU
Im Reg Dm Reg
o
n
s
Problèmes avec les Pipelines?
° Types d ’aléas (« hazards ») :

• Aléas de structure: utilisation d’une même ressource plusieurs
fois en même temps
• Aléas de données: utilisation d’une donnée avant qu’elle soit

prête
- instruction dépend des résultats d ’une instruction
antérieure encore dans le pipeline
• Aléas de contrôle: prendre décision avant d’évaluer la condition

(’exécution d’un saut est réalisée avec un certain retard)
- instruction de saut conditionnel
Aléas résolus par suspension (attente) (les
instructions qui précédent celle qui produit l’aléa peuvent
continuer, mais toutes les autres sont arrêtées jusqu’à la
disparition de l’aléa)
• contrôle du pipeline doit détecter l’aléa
• prendre l’action nécessaire pour résoudre l’aléa
Mémoire : Aléas de structure
Temps
ALU
Mem Reg Mem Reg
Load
ALU
Mem Reg Mem Reg
Instr 1
ALU
Mem Reg Mem Reg
Instr 2
ALU
Mem Reg Mem Reg
Instr 3
ALU
Mem Reg Mem Reg
Instr 4
Détection facile !
Les aléas de structure peuvent être éliminés en agissant sur l'architecture du
processeur lors de sa conception. Par contre, les aléas de données et de
contrôle ne peuvent pas être éliminés.
Solution : Mémoire cache d’instructions, cache de données

Aléas de contrôle
•La présence d'un pipeline introduit des complications lors de

l'exécution d'un saut conditionnel.
•La condition qui permet au séquenceur de déterminer si le saut
est pris ou non n'est généré que lorsque l'instruction précédente
arrive à l'étage d'exécution.
•L'étage de décodage de l'instruction n'est pas en mesure de
calculer l'adresse de l'instruction suivante avant de connaître la
valeur de condition.

Aléas de contrôle
Solution 1:
Suspension: attendre jusqu’à ce que la décision
puisse être prise
Temp (en cycles)
ALU
Mem Reg Mem Reg
Add
ALU
Mem Reg Mem Reg
Beq
ALU
Load Mem Reg Mem Reg
° Impact: 2 cycles / instruction de saut conditionnel

=> lenteur

Observations sur la (Solution 1)
• Une solution possible aux aléas de contrôle est de

retarder l'exécution des instructions suivantes.
• Cette opération introduit un délai qui est relativement
important à cause du grand nombre d'instructions de saut
dans un programme (les sauts conditionnels représentent
environ 11-17% des instructions dans un programme)

Aléas de Contrôle
Solution 2:
° Prédiction: suppose une des deux possibilités, et on
corrige en cas d ’erreur
Temps (en cycles)
ALU
Mem Reg Mem Reg
Add
ALU
Mem Reg Mem Reg
Beq
ALU
° Impact: 0 cycles / instruction saut si prédiction est

correcte, 2 cycle en cas d ’erreur (correcte - 50%)

•Une autre solution possible au problème des aléas de

contrôle est l'exécution spéculative.
•Le processeur peut essayer de "deviner" si le branchement
sera pris ou pas pris (branch prediction) et commencer à
exécuter les instructions correspondant à cette décision.
•Si le choix se révèle correct, la pénalité de branchement est
éliminée.
•Si le choix se révèle incorrect, il faudra vider le pipeline et
charger l'instruction correcte (2 cycles perdus)

Aléas de contrôle
Solution 3:
° Redéfinir saut conditionnel: avec effet après instruction suivante
(saut avec effet retardé)
Temps (en cycles)
ALU
Mem Reg Mem Reg
Add
ALU
Mem Reg Mem Reg
Beq
ALU
Misc Mem Reg Mem Reg
ALU
° Impact: 0/cycles par instruction saut si on peut remplir la case

instruction après saut

•Une troisième solution au problème des aléas de contrôle

peut être fournie par le compilateur, qui peut "anticiper"
l'instruction qui génère la condition .
•Si le bon nombre (défini par l'architecture) d'instructions est
intercalé entre la génération de condition et le saut, celui-ci
peut s'effectuer sans délai.
•Il faut toutefois remarquer que cette anticipation est souvent
impossible et qu'elle est spécifique à une architecture donnée,
pouvant générer des résultats erronés sur des architectures
différentes.
Aléas de données sur r1
add r1 ,r2,r3 Trois types d’Aléas de données:
sub r4, r1 ,r3  Type 1 entre add et sub
and r6, r1 ,r7 Type 2 entre add et and

Type 3 entre add et or (qui
or r8, r1 ,r9
revient à un aléas de structure)
xor r10, r1 ,r11

Aléas de donnée sur r1
Temps (en cycles)

IF ID/RF EX MEM ER
ALU
Reg Reg
add r1,r2,r3 Im Dm
ALU
Im Reg Dm Reg
sub r4,r1,r3
ALU
Im Reg Dm Reg
and r6,r1,r7
ALU
Im Reg Dm Reg
or r8,r1,r9
ALU
Im Reg Dm Reg
xor r10,r1,r11

Aléas de donnée sur r1
Solution1:
• “Renvoyer” résultat d ’une étape vers une autre
Temps (en cycles)
IF ID/RF EX MEM ER
ALU
Reg Reg
add r1,r2,r3 Im Dm
ALU
Im Reg Dm Reg
sub r4,r1,r3
ALU
Im Reg Dm Reg
and r6,r1,r7
ALU
Im Reg Dm Reg
or r8,r1,r9
ALU
Im Reg Dm Reg
xor r10,r1,r11
• “or” OK si on définit proprement lecture/ecriture

•Introduction de matériel supplémentaire.

•Introduire une connexion directe entre la sortie de l'étage
d'exécution et l'étage de chargement des opérandes, permettant
au résultat d'une instruction d'être un opérande de l'instruction
suivante.
•Cette méthode est coûteuse en logique de contrôle
supplémentaire.

Aléas de données: cas Load
Solution 2 : Suspension
Dépendance en arrière
Temps (en cycles)
IF ID/RF EX MEM ER
ALU
Reg Reg
lw r1,0(r2) Im Dm
ALU
Im Reg Dm Reg
sub r4,r1,r3
•Renvoi impossible
• Suspension est la seule solution

•Une solution relativement simple pour traiter les aléas de

données.
•Retarder l'exécution des instructions concernées en les
bloquant à l'étage de chargement des opérandes.
•Le délai introduit par cette méthode est loin d'être
négligeable.

Conception du processeur avec pipeline
° Revoir le chemin de données et le diagramme de

contrôle
° Association des ressources aux états
° Résoudre tous les conflits (aléas)
° Assertion de contrôle à chaque étape

Next PC
NHA/MMY Pipeline
PC
Inst. Mem
IR
Valid
Reg
File Dcd Ctrl
B
A
IRex
Based on UCB
Cond=
Exec Ex Ctrl
° Une instruction à chaque cycle?
IRmem
Processeur avec pipeline
Mem
Access
Mem Ctrl
M
Data
Mem IRwb
Banc WB Ctrl
Regs.
Page : 26
Processeur avec pipeline
ER
ER ER
M M
EX
Contrôle
EI/DI DI/EX EX/MEM MEM/ER

Chemin & Contrôle
IR <- Mem[PC]; PC <– PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B; S <– A or ZX; S <– A + SX; S <– A + SX; If Cond

PC < PC+SX;
M <– Mem[S] Mem[S] <- B
Cond=
R[rd] <– S; R[rt] <– S; R[rd] <– M;
Regs.
Banc
Inst. Mem
Exec
Reg
Next PC
A
File
S
PC
IR
B M
Access
Mem
Mem
Data
D
Instruction de chargement
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
Clock
1er lw Ifetch Reg/Dec Exec Mem Wr
2em lw Ifetch Reg/Dec Exec Mem Wr
3em lw Ifetch Reg/Dec Exec Mem Wr
° Les 5 unités indépendantes du chemin données

pipeline:
• Mémoire Instruction pour étape Ifetch
• Port lecture du Banc Registres (bus A et bus B) pour étape Reg/Dec
• ALU pour étape Exec
• Mémoire données pour étape Mem
• Port lecture du Banc Registres port écriture (bus W) à l ’ étape Wr

Instruction type-R
Cycle 1 Cycle 2 Cycle 3 Cycle 4
R-type Ifetch Reg/Dec Exec Wr
° Ifetch
• Lecture de l ’instruction de mémoire instructions
° Reg/Dec
• Lecture registres et décodage de l ’instruction
° Exec
• Opération ALU sur les deux registres
° Wr
• Ecriture résultat dans un registre

Pipeline avec type-R et Load
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9
Clock
R-type Ifetch Reg/Dec Exec Wr Problème!
Load Ifetch Reg/Dec Exec Mem Wr
° Un conflit (aléas de structure):

• Deux instructions :écriture dans le Banc registre en même temps!
• Un seul port écriture

Observations importantes
° Chaque unité ne peut être utilisée plus d ’une seule
fois par instruction
° Chaque unité doit être utilisée dans la même étape à
chaque instruction:
• Chargement utilise port écriture du banc registre dans la 5em étape
1 2 3 4 5
• R-type utilise le port écriture du banc registre dans la 4em étape
1 2 3 4
° 2 manières pour résoudre ce problème.

Solution 1: Suspension du pipeline
Clock
Ifetch Reg/Dec Exec Wr
R-type Ifetch Reg/Dec Bulle Exec Wr

R-type Ifetch Pipeline Reg/Dec Exec Wr
Ifetch Reg/Dec Exec
° Insertion de “bulle” pour élimination de conflit:

• Logique de contrôle compliquée.
• Pas de démarrage de nouvelle instruction.
° Pas de démarrage d’instruction en Cycle 6!

Solution 2: Ralentir l’instruction type-R
• Écriture dans le banc registre se fait au cycle 5 au lieu de 4
• NOOP (pas d’opération) pour étape Mem
1 2 3 4 5
R-type Ifetch Reg/Dec Exec Mem Wr

Clock

Modification Chemin&Contrôle
IR <- Mem[PC]; PC <– PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B; S <– A or ZX; S <– A + SX; S <– A + SX; if Cond PC

< PC+SX;
M <– S M <– S M <– Mem[S] Mem[S] <- B
Cond=
R[rd] <– M; R[rt] <– M; R[rd] <– M;
Regs.
Banc
Inst. Mem
Exec
Reg
Next PC
A M
File
S
PC
IR
Access
Mem
Mem
Data
D
Les 4 Etapes du rangement
Cycle 1 Cycle 2 Cycle 3 Cycle 4
Store Ifetch Reg/Dec Exec Mem
° Ifetch: Lecture instruction de mémoire instructions

° Reg/Dec: Lecture registres et décodage instruction
° Exec: Calcul adresse mémoire
° Mem: Ecriture données dans mémoire données

Les 3 Etapes du Saut Conditionnel (Beq)
Cycle 1 Cycle 2 Cycle 3
Beq Ifetch Reg/Dec Exec
° Ifetch: Lecture instruction de mémoire instructions

° Reg/Dec: Lecture registres et décodage instruction
° Exec:
• Comparaison des deux registres
• Sélection de l ’adresse de saut
• Chargement PC : Aléas de Contrôle possible!

Diagramme de contrôle
IR <- Mem[PC]; PC < PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B; S <– A or ZX; S <– A + SX; S <– A + SX; If Cond PC

< PC+SX;
M <– S M <– S M <– Mem[S] Mem[S] <- B
Cond=
R[rd] <– S; R[rt] <– S; R[rd] <– M;
Regs.
Banc
Inst. Mem
Exec
Reg
Next PC
A M
File
S
PC
IR
Access
Mem
Mem
Data
D
Chemin & Contrôle
IR v v v
fun wb
wb
Mem Inst
Decode
wb
me me
rt ex Exec WB
Mem
Ctrl Ctrl
rs Ctrl
op im
rs rt
Banc
Reg.
Banc
Reg. A M
Exec
S
Donn.
Accé
Mem
Mem
D
PC Suiv.
PC

Essai d’exécution
10 lw r1, r2(35)
14 addI r2, r2, 3
20 sub r3, r4, r5
24 beq r6, r7, 100
28 ori r8, r9, 17
32 add r10, r11, r12
…
100 and r13, r14, 15

Fetch 10
n n n
Mem Inst n
Decode
Exec WB
Mem
Ctrl Ctrl
Ctrl
rs rt
Banc
Reg.
Banc
Reg.
A M
Exec
S
B 10 lw r1, r2(35)
Donn.
Accé
Mem
Mem
D 14 addI r2, r2, 3
20 sub r3, r4, r5
PC Suiv.
24 beq r6, r7, 100

10
30 ori r8, r9, 17

34 add r10, r11, r12
…
100 and r13, r14, 15

Fetch 14, Decode 10
n n n
lw r1,r2,3
Mem Inst
Decode
Exec WB
Mem
Ctrl Ctrl
Ctrl
rs rt
Banc
Reg.
Banc
Reg.
A M
Exec
S
B 10 lw r1, r2(35)
Donn.
Accé
Mem
Mem
14 addI r2, r2, 3
D
20 sub r3, r4, r5
PC Suiv.
24 beq r6, r7, 100

14
30 ori r8, r9, 17

34 add r10, r11, r12
…
100 and r13, r14, 15

Fetch 20, Decode 14, Exec 10
n n
addi r2, r2, 3
Mem Inst
lw r1
Decode
Exec WB
Mem
Ctrl Ctrl
Ctrl
35
2 rt
Banc
Reg.
Banc
Reg.
A M
Exec
S
B
10 lw r1, r2(35)
Donn.
Accé
Mem
Mem
D 14 addI r2, r2, 3
20 sub r3, r4, r5
PC Suiv.
24 beq r6, r7, 100

20
30 ori r8, r9, 17

34 add r10, r11, r12
…
100 and r13, r14, 15
Fetch 24, Decode 20, Exec 14, Mem 10
n
sub r3,r4, r5
Mem Inst
Lw r1
addi r2
Decode
Exec WB
Mem
Ctrl Ctrl
Ctrl
3
4 5
Banc
Reg.
Banc
Reg.
r2+35
A M
Exec
B
10 lw r1, r2(35)
Donn.
Accé
Mem
Mem
D 14 addI r2, r2, 3
20 sub r3, r4, r5
PC Suiv.
24 beq r6, r7, 100

24
30 ori r8, r9, 17

34 add r10, r11, r12
…
100 and r13, r14, 15
???………….FIN

Chap7 Pipeline

Transféré par

Informations du document

Titre original

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

Chap7 Pipeline

Transféré par

Droits d'auteur :

Formats disponibles

Notion de Pipeline

Exemple: Opération de lavage du linge

4 personnes ; chacun doit :

NHA/MMY Pipeline Based on UCB Page : 1

NHA/MMY Pipeline Based on UCB Page : 3

° Traitement en pipeline n ’améliore pas le temps de

NHA/MMY Pipeline Based on UCB Page : 4

LW Ifetch Reg/Dec Exec Mem Wr

° Ifetch: Fetch de l ’instruction

° Chemin données : Insertion d ’autres registres

IFetch Dcd Exec Mem WB

IFetch Dcd Exec Mem WB

IFetch Dcd Exec Mem WB

IFetch Dcd Exec Mem WB

IFetch Dcd Exec Mem WB

NHA/MMY Pipeline Based on UCB Page : 6

SW Ifetch Reg Exec Mem Wr

R-type Ifetch Reg Exec Mem Wr

NHA/MMY Pipeline Based on UCB Page : 7

° Exécution de 100 instructions

NHA/MMY Pipeline Based on UCB Page : 8

° Types d ’aléas (« hazards ») :

• Aléas de données: utilisation d’une donnée avant qu’elle soit

• Aléas de contrôle: prendre décision avant d’évaluer la condition

NHA/MMY Pipeline Based on UCB Page : 11

•La présence d'un pipeline introduit des complications lors de

NHA/MMY Pipeline Based on UCB Page : 12

Temp (en cycles)

° Impact: 2 cycles / instruction de saut conditionnel

NHA/MMY Pipeline Based on UCB Page : 13

• Une solution possible aux aléas de contrôle est de

NHA/MMY Pipeline Based on UCB Page : 14

° Impact: 0 cycles / instruction saut si prédiction est

NHA/MMY Pipeline Based on UCB Page : 15

•Une autre solution possible au problème des aléas de

NHA/MMY Pipeline Based on UCB Page : 16

° Impact: 0/cycles par instruction saut si on peut remplir la case

NHA/MMY Pipeline Based on UCB Page : 17

•Une troisième solution au problème des aléas de contrôle

add r1 ,r2,r3 Trois types d’Aléas de données:

sub r4, r1 ,r3  Type 1 entre add et sub

and r6, r1 ,r7 Type 2 entre add et and

NHA/MMY Pipeline Based on UCB Page : 19

Temps (en cycles)

NHA/MMY Pipeline Based on UCB Page : 20

• “or” OK si on définit proprement lecture/ecriture

•Introduction de matériel supplémentaire.

NHA/MMY Pipeline Based on UCB Page : 22

NHA/MMY Pipeline Based on UCB Page : 23

•Une solution relativement simple pour traiter les aléas de

NHA/MMY Pipeline Based on UCB Page : 24

° Revoir le chemin de données et le diagramme de

NHA/MMY Pipeline Based on UCB Page : 25

EI/DI DI/EX EX/MEM MEM/ER

NHA/MMY Pipeline Based on UCB Page : 27

A <- R[rs]; B<– R[rt]

S <– A + B; S <– A or ZX; S <– A + SX; S <– A + SX; If Cond

M <– Mem[S] Mem[S] <- B

1er lw Ifetch Reg/Dec Exec Mem Wr

2em lw Ifetch Reg/Dec Exec Mem Wr

3em lw Ifetch Reg/Dec Exec Mem Wr

° Les 5 unités indépendantes du chemin données

NHA/MMY Pipeline Based on UCB Page : 29