12/10/2012

Principe du pipeline
Unit 1 Unit 2 Unit 3 Unit 4 Unit 5 Unit 6

1 2 3 4 5
Jean-luc.dekeyser@lifl.fr T6 T6 T6 T6 T6
Unit 1 2 3 4 5 6
Version 2013 T5 T5 T5 T5 T5 T5
1 2 3 4 5 6 7
FONCTIONNEMENT PIPELINE 1
T4
2
T4
3
T4
4
T4
5
T4
6
T4
7
T4
8
T3 T3 T3 T3 T3 T3 T3 T3
1 2 3 4 5 6 7 8 9
T2 T2 T2 T2 T2 T2 T2 T2 T2
T 11 T 21 T 31 T 41 T 51 T 61 T 71 T 81 T 91 T 10
1

temps 4

Système pipeline Définitions

 Superposition dans le temps
 Augmentation des performances
 Parallélisme temporel
 Latence du pipeline : temps (en cycles ) entre
deux instructions consécutives
 Débit du pipeline : Nombre d'instructions
exécutées par cycle, on appelle aussi le degré
d'un processeur superscalaire
 Conflit sur ressource : Deux ou plus
instructions demandent l'utilisation de la
même unité au même instant

2 5

Transfert des données

Décomposition
pipeline
Modèle Asynchrone:
 Division d'une tâche en sous tâches
 Mécanisme de "handshacking" entre chaque
 1 unité logique / sous tâche
couple d'unités
 Les sorties d'une unité sont
connectées aux entrées de la suivante
DATA
 Les données entrent par le premier Etage i Etage i + 1
Ready
étage et sortent par le dernier.
ACK

3 6

1
 12/10/2012

Modèle Synchrone Pipeline d'instructions:

 Horloge contrôle le transfert des données  Fetch / Execute 2 unités séparées
entre 2 unités Phase de Phase d'
Chargement exécution
 Pipe d'instructions
 Pipe arithmétique

DATA DATA DATA  On réalise les deux phases en même temps

Etage Etage Etage Etage sur des instructions différentes.
i i+1 i+2 i+3  Il suffit de connaître la prochaine instruction:
instruction prefetch
Horloge7 10

Construction Pipeline 2 étages

Latch
 Utilisation de latch
Execute

Fetch

Temps d’exécution constant

Horloge
 Sans latch (CRAY) Execute
 On parle de Maximum Rate pipe-line
Fetch

Temps d’exécution variable

8 11

Augmentation du
Speed-up parallélisme
 Sur un pipe n-étages, il faut:  L'instruction prefetch permet au plus
 n cycles pour obtenir le 1er résultat de doubler la vitesse du processeur.
 pour s-1 résultats, il faut ensuite s-1 cycles.
 Soit n+s-1 cycles pour s résultats
 Exécution souvent plus long que le
(sur un processeur scalaire, il faut ns cycles) chargement.
 Le Speed-up est égal à  La recherche de parallélisme
S = Tscal /Tpipe = ns nécessite un découpage plus fin
n+s-1
 S  n quand s +
 Souvent en 4 ou 5 étapes successives

9 12

2
 12/10/2012

5 étages Le pipe-line du 80486

 Fetch/ Decode/ Fetch OP/ Execute/ Store  Fetch: Instructions depuis le cache ou la mémoire vers
2 buffers de prefetch. Chaque buffer contient en
moyenne 5 instructions. Remplissage dès que possible
1 IF ID FO EX SO des buffers.
2 IF ID FO EX SO
3 IF ID FO EX SO  Decode stage 1: Décode le code opération et les
4 IF ID FO EX SO modes d’adressage
5 IF ID FO EX SO
 Decode stage 2: Génère les signaux pour l’ALU.
Réalise les adressages plus complexes
 Execute: Opérations ALU, Accès cache, registres
5 actions  Write Back: Maj des flags, écriture des résultats sur le
en parallèle cache et le buffer de l’interface du Bus
13 16

Exemple le MIPS Efficacité

 Fetch/ Decode/ Execute/ Memory/ Register  Soit ti le temps de traversée de l'étage
i.
1 IF ID EX MEM REG
2
3
IF ID
IF
EX
ID
MEM
EX
REG
MEM REG
 Le temps d'exécution d'une instruction
4 IF ID EX MEM REG est: tinst = ti
5 IF ID EX MEM REG
 Le délai entre 2 instructions
successives est tD = Maxiti
ID : Decode + fetch operands 5 actions tD est appelé cycle du pipeline
Mem : write back cache + mem en parallèle
Reg : store ALU into register
14 17

Exemple le MIPS Rupture de pipeline

 Fetch/ Decode/ Execute/ Memory/ Register  Instructions de branchement
1 IF ID EX MEM REG  Data dépendance
2 IF ID EX MEM REG
3 IF ID EX MEM REG  Défauts de cache
4 IF ID EX MEM REG
5 IF ID EX MEM REG  Conflits hardware (mémoire)

ID : Decode + fetch operands 5 actions

Mem : write back cache + mem en parallèle
Reg : store ALU into register
15 18

3
 12/10/2012

Instructions de Branchement Buffer d'instructions

 Lors de l'exécution d'un JUMP  FIFO d'instructions : assure un flux
 La prochaine instruction est la constant
suivante  On utilise 2 FIFOs
 OK  Une pour les instructions suivant le
 Ce n'est pas la suivante JUMP
 Vidage du pipe-line  Une pour les instructions à l'adresse
 Remplissage du pipe avec les du JUMP
bonnes instructions 19 22

Réduction de la vitesse Multiple pre-fetch

x  On charge les 2 FIFOs après un JUMP
EX x
x  Après le JUMP, on choisit l'instruction
x
x
dans l'une des 2 FIFOs
Abandon  Si plusieurs JUMP pris en compte, il
 10 à 20% des instructions sont des faut plusieurs FIFO (2n = n JUMP)
JUMP  Augmente les conflits d’accès
 réduction de la vitesse globale mémoire
 Boucle TantQue, Exit
20 23

Réduction des ruptures Double FIFO

 4 techniques pour réduire les ruptures
Séquentiel
de pipeline
 Buffer d'instructions
Mémoire

Fetch FIFO ...

 Loop buffer
 Table de branchement
Non séquentiel
 Branchement retardé

21 24

4
 12/10/2012

Loop Buffer Decode history table

Adresse Adresse
 Petite mémoire rapide contrôlée par l’unité Instruction branchement
de chargement des instructions Recherche
dans table Adresse
 Contient les N instructions les plus
récemment chargées. de branchement

 Fonctionnement comme un cache

d’instructions mais en séquence Adresse
CO
 A chaque fetch on recherche d’abord trouvée
Adresse
l’instruction dans le loop buffer Fetch Decode Execute
Instruction
25 28

Fonctionnement Branchement retardé

 Avec le prefetch, quelques instructions  Les instructions de JUMP sont placées
suivantes sont présentes. dans le code avant qu'elles ne
 Si le JUMP saute quelques instructions en prennent effet
avant, on peut la trouver dans le buffer ex: if
then else  Pour un pipeline à 2 étages , le JUMP
 Si le JUMP saute vers le début d’une boucle, prend effet après la prochaine
la boucle complète peut se trouver dans le instruction
buffer  n étages : le JUMP prend effet après
 Cray 1, motorola 68010 les n-1 suivantes
26 29

Table de Branchement Pour un 2 étages

 Prédire dynamiquement l'adresse
suivante : utilisation répétée de la
même adresse Execute
Jump NEXT
 La 1ère exécution range l'adresse de
branchement Fetch
Jump NEXT
Adresse
Saut
 Lorsque la même instruction JUMP
est exécutée (Fetch), on utilise
l'adresse mémorisée dans une table
(mémoire rapide)
27 30

5
 12/10/2012

Efficacité Fonctionnement
 Pas de vidage de pipe  Détection de la dépendance et
 Optimisation du compilateur blocage de pipeline jusqu'à résolution.
 70% des JUMP peuvent être suivis  Autoriser le chargement des
d'une instruction RISC instructions qui sont indépendantes
(pas de data dépendance)
 On ne retarde que les instructions
dépendantes.

31 34

Data dépendances
 Exemple:
C = 2 * (A + [@100])

ADD AX, [100]% A+100%

SAL AX, 1 %*2%
MOV CX, AX %C% SUPERSCALAIRE /
SUPERPIPELINE

32 35

Sur 5 étages Superscalaire (1987)

Dépendances
de données
 CISC et RISC produisent une
Store AX AX CX
instruction par cycle.
 Sur un superscalaire on produit
Exec ADD Shift
AX
plusieurs instructions par cycle.
Fetch AX AX
Op [100]  On utilise plusieurs pipelines
Decode d'instructions.
Fetch ADD SAL Mov

Conflit mémoire : entre fetch et accès [100] 33 36

6
 12/10/2012

Taux de parallélisme Superpipeline (1988)

 Les superscalaires permettent  Utilisation d’une horloge multiphase
d'extraire encore plus de parallélisme.  Redécomposition pipeline de chaque
 Toutes les instructions indépendantes étage du pipeline d’instruction
peuvent être exécutées en même  Demande une fréquence d’horloge
temps (limité par le nombre de élevée
pipeline)  Exemple R4000

37 40

Fonctionnement Fonctionnement

1 IF ID FO EX SO 1 IF1 IF2 ID1 ID2 FO1 FO2 E X1 EX2 SO1 SO2

2 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
2 IF ID FO EX SO
1 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
1 IF ID FO EX SO 2 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
2 IF ID FO EX SO 1 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
1 IF ID FO EX SO 2 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
1 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
2 IF ID FO EX SO
2 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
1 IF ID FO EX SO 1 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
2 IF ID FO EX SO 2 IF1 IF2 ID1 ID2 FO1 FO2 EX1 EX2 SO1 SO2
1 IF ID FO EX SO
2 IF ID FO EX SO

10 actions 10 actions
en parallèle 38 en parallèle 41

Efficacité Limitations
 Par observation, en moyenne on peut  Augmenter le parallélisme au niveau de
obtenir deux instructions à exécuter l’instruction
 Compilateur ou Hardware
en parallèle.
 5 limitations
 On limite le degré du processeur à 3  Dépendance de flot
ou 5. (projet de degré à 16 sur Alpha -  Dépendance procédurale
utilisation multi-user)  Conflits sur ressources
 Dépendance de sortie
 Antidépendance

39 42

7
 12/10/2012

Dépendance de flot Instruction-issue

 Exemple:  Ordre dans lequel le processeur exécute les
 add R1, R2 différentes étapes des instructions
move R3, R1  Ordre de fetch
 La deuxième instruction ne peut être exécutée  Ordre d’exécution
tant que la première n’est pas exécutée  Ordre de modification des registres ou mémoires
 Modifier l’ordre en assurant une exécution
Pipe1 IF D X W correcte
Pipe2 IF D X W

43 46

Dépendance procédurale Les stratégies

 Présence de Branch impose le vidage de tous  Accès et exécution ordonnés
les pipes  Accès ordonné et exécution désordonnée
inst1 IF D X W  Accès et exécution désordonnés
branch IF D X W
inst2 IF D X W
inst3 IF D X W
IF D X W
IF D X W

44 47

Conflit sur ressource Accès et exécution ordonnés

 Utilisation de la même unité fonctionnelle,  Même ordre que sur une machine
mémoire, cache, bus... séquentielle.
 On peut supprimer ce conflit en dupliquant  Exemple:
les ressources ou en pipelinant les unités  superscalaire avec Fetch et Decode deux
fonctionnelles instructions en parallèle
 3 unités fonctionnelles
Add IF D X W  2 unités d’écriture des résultats
Add IF D X W

45 48

8
 12/10/2012

Exemple Dépendance de sortie

 I1 demande 2 cycles pour exécution  Exemple:
Dépendance de flot
 I3 et I4 sont en conflit sur une unité  R3 = R3 + R5
fonctionnelle Dépendance de sortie
R4 = R3 + 1
 I5 dépend du résultat produit par I4
 I5 et I6 sont en conflit sur une unité R3 = R5 +1
fonctionnelle
R7 = R3 + R4

49 52

Accès et exécution ordonnés Exécution désordonnée

Decode Execute WriteBack Decode Execute WriteBack

50 53

Accès et exécution
Exécution désordonnée désordonnés
 Utile pour les instructions demandant  Découplage des étages decode et execute
plusieurs cycles  Un buffer d’instructions: Instruction Window
 Exemple: floating point sur Motorola 88000  Decode place les instructions dans la fenêtre
 Autant d’instructions en exécution qu’il y a  Quand une UF devient libre elle obtient une
d’unités instruction exécutable dans la fenêtre:
 Respect des dépendances de flot et ressource et dépendance
procédurale
 Dépendance de sortie

51 54

9
 12/10/2012

Fonctionnement Renommage des registres

 Le choix parmi les instructions à exécuter est  Eliminer les dépendances de sorties et
plus large antidépendances
 Respect des dépendances  Plusieurs instructions utilisent le même
 Respect de l’antidépendance registre
 Allocation dynamique des registres par le
processeur ( ce n’est plus le compilateur)
 Un même registre du code peut référencer
plusieurs registres lors de l’exécution

55 58

Antidépendance Pour notre exemple

 Exemple:
Dépendance de flot  Exemple:
– R3 = R3 + R5
 R3b = R3a + R5a

R4 = R3 + 1 Dépendance de sortie
R4b = R3b + 1

R3 = R5 +1 R3c = R5a +1
Antidépendance
R7 = R3 + R4 R7b = R3c + R4b

56 59

Accès et exécution
désordonnés Compilation
Decode Window Execute WriteBack  Lorsque l'on ne peut exécuter autant
d'instructions que le degré du processeur,
certains pipelines restent en attente.
 Le nombre d'instructions en cours
d'exécution dépend des dépendances de
données entre les instructions, et des conflits
d’accès aux ressources
 Le travail du compilateur devient capital:
réorganisation du code...
57 60

10