Architecture pipe-line : réordonnancement statique

ENSIMAG filières SLE / ISI Architecture avancée
________________________________________________________________________________
TD6
ARCHITECTURE PIPE - LINE : RÉORDONNANCEMENT STATIQUE
La technique de by pass utilisée pour résoudre les dépendances de données dans des processeurs
pipe-line travaillant sur des entiers (integer processor) devient vite inopérante pour des processeurs
ayant une partie opérative complexe, imposant de nombreux cycles d’attente (bulles ou stalls) en
cas de dépendances , par exemple :
- accès mémoire lents, en plusieurs cycles d’horloge,
- opérateurs complexes, par exemple opérateurs de calcul flottant, (calcul en 4 à 30 périodes
d’horloge).
i1 IF ID EX1 EX2 EX3 WB
i2 IF ID stall stall EX1
Diagramme pour des instructions sur flottants (opération en 3 périodes d’horloge)
Quand il y a risque de nombreux cycles d’attente, il est nécessaire de réorganiser le programme
pour obtenir des performances intéressantes ; ce réordonnancement peut être effectué par le
compilateur (réordonnancement statique) et est particulièrement intéressant pour les corps de boucle
du programme.
L’inconvénient est que cette optimisation est effectuée pour une réalisation précise du processeur, et
que le code doit être optimisé à nouveau, donc recompilé, pour une autre réalisation : pour
améliorer les performances d’un processeur, il est classique d’augmenter la fréquence d’horloge,
donc le nombre de cycles d’horloge nécessaires pour une opération (à technologie similaire). Le
nombre de cycles d’attente à éviter augmente, demandant une optimisation plus poussée pour
utiliser au mieux les performances du nouveau processeur.
Note 1 : les opérateurs flottants sont en général pipe-line (à l’exception de l’opérateur de division) :
une opération flottante peut être lancée à chaque cycle d’horloge.
Note 2 : le réordonnancement peut aussi être effectué par le processeur lui-même, à l’exécution : on
parle alors de réordonnancement dynamique. Le processeur examine une séquence d’instructions et
lance celles qui sont exécutables (dont tous les opérandes sont disponibles) : « out of order
instruction issue ». Le problème est alors de suivre à la trace les opérandes des instructions mises en
attente.

- 2 -
EXERCICE : OPTIMISATION DE PROGRAMME POUR UN PROCESSEUR PIPE-LINE
Le processeur utilisé est caractérisé par :
formats : mot mémoire de 32 bits, adresses 32 bits, traitant des entiers codés
sur 32 bits et des flottants codés sur 64 bits
registres : 16 registres pour valeurs entières R0, ..., R15, avec R0 = 0
16 registres pour valeurs codées en flottant : F0, ..., F15
modes d'adressage Registre Ri
Avec déplacement par rapport à un registre Radr : depl(Radr)
Relatif au compteur programme pour les branchements
jeu LDW Rdest, depl(Radr) Rdest := Mém(Radr+depl)
LDL Fdest, depl(Radr) Fdest := Mém(Radr+depl)
d'instructions STW Rsrc , depl(Radr) Mém(Radr+depl) := Rsrc
STL Fsrc , depl(Radr) Mém(Rsrc+depl) := Fsrc
opint Rdest, Rsrc1, Rsrc2 Rdest := Rsrc1 opint Rsrc2
opflo Fdest, Fsrc1 Fsrc2 Fdest := Fsrc1 opflo Fsrc2
Bcc Rscr, label branchement à label si Rsrc remplit
la condition indiquée par cc (z ou nz)
Soit un programme qui ajoute une valeur flottante fixe (stockée dans F0) à un tableau de n
nombres flottants T(1 : n) dont l'adresse est dans R1 (adresse de T(1)).
ADDint R2, R0, n
boucle: LDL F1, 0(R1)
ADDflo F2, F1, F0
STL F2, 0(R1)
ADDint R1, R1, 8
SUBint R2, R2, 1
BNE R2, boucle
Le processeur étant pipe-line, une instruction peut être lue et son exécution peut commencer à
chaque période d'horloge, en l'absence de conflits et de dépendances. On suppose les conflits
matériels résolus ; il reste le problème des dépendances, d'autant plus important que les
opérations en flottant s'exécutent en plusieurs cycles, sur des opérateurs qui sont eux-mêmes
pipe-line (on peut lancer une opération en flottant à chaque cycle, mais le résultat n'est pas
immédiatement disponible).
Le nombre de cycles d'attente entre 2 instructions dépendantes qui se succèdent (instruction i
et instruction i+1) est donné dans le tableau suivant :

- 3 -
Inst.W Reg. W
Inst. R
Reg. R Nombre de stalls
LDW Rdest LDW Radr 1
LDL Radr 1
STW Radr 1
STL Radr 1
OPint Rsrc1 1
OPint Rscr2 1
Bcc Rsrc 2
LDL Fdest OPflo Fsrc1 1
OPflo Fsrc2 1
STL Fsrc2 1
OPint Rdest Bcc Rsrc 1
OPflo Fdest OPflo Fsrc1 3
OPflo Fsrc2 3
STL Fsrc 3
Bcc label Toute
instructon 1
On voit par exemple :
- qu’après un LDL, il faut attendre 1 cycle pour utiliser la valeur lue en mémoire pour une
opération flottante,
- qu'après un branchement, il faut toujours attendre 1 cycle pour commencer à exécuter
l'instruction suivante.
Question 1 :
Combien de cycles sont nécessaires pour chaque itération, pour la boucle donnée ci-dessus ?
Peut-on réorganiser les instructions pour diminuer ce nombre de cycles (en les modifiant un
peu éventuellement) ?
Question 2 : Une façon d'optimiser le temps d'exécution d'un programme est de "dérouler" les
boucles.
A partir du programme initial, proposer une boucle qui contienne 2 des itérations de la boucle
proposée (on suppose que la dimension du tableau est multiple de 2). Utiliser pour cela autant
de registres que nécessaire (registres flottant distincts pour chaque itération d'origine) et
supprimer les instructions redondantes. Quel est le nombre de cycles par itération d'origine ?
Réorganiser le programme obtenu pour minimiser les cycles d'attente et donner le nombre de
cycles par itération d'origine. Idem en déroulant la boucle 4 fois.

- 4 -
Question 3 : on ne s’intéresse qu’aux instructions « importantes » de la boucle, la séquence
LDL, ADDflo, STL.
Imaginons qu’on crée un circuit spécialisé pour exécuter itérativement cette séquence, avec
une mémoire file où sont lus les opérandes, un opérateur et une autre mémoire file où sont
écrits les résultats (pipe-line matériel) : le diagramme ci-dessous met en évidence l’exécution
pipe-line sur ce circuit spécialisé, avec trois phases : prologue, itération et épilogue.
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
LDL ADDflo STL
prologue n –2 itérations avec pipe-line plein épilogue
La technique du pipe-line logiciel (software pipe-lining) consiste à implémenter ce
diagramme par programme sur un processeur.
Proposer un tel programme pour l’exemple traité.
Question 4 : on peut modifier le processeur en implémentant un branchement à effet retardé
(d'une instruction).
Réécrire les programmes des questions 1 et 3 en les optimisant et donner le nombre de cycles
par itération.
Question 5 : processeur VLIW (very large instruction word)
0n décide de modifier le processeur : ce processeur dispose d'un opérateur flottant et d'un
opérateur entier distincts (ainsi que de jeux de registres entier et flottant distincts), donc d'une
partie opérative avec de fortes possibilités de parallélisme qui ne sont pas complètement
exploitées par l'exécution séquentielle des instructions. On le modifie pour qu'il puisse
exécuter des "super instructions", qui comportent une instruction normale (toute instruction
sauf une opération en flottant) et une instruction de type OPflo. Par exemple :
LDL Fj, depl(Ri) ADDflo Fk,Fl,Fm

- 5 -
CONVENTION :
- quand un registre est lu et écrit dans la même ligne, c’est l'ancienne valeur qui est lue (dans l’instruction ci-
dessus, si Fm = Fj, la valeur de l’opérande utilisée pour ADDflo est celle avant l’exécution du LDL),
- quand un des opérandes de la super instruction n’est pas disponible, l’instruction est mise en attente (même si
une des opérations est exécutable).
Ce fonctionnement est plutôt proche de la microprogrammation i.e. de la réalisation du séquenceur d’un
processeur pour des instructions complexes (par exemple, DSP).
Réécrire les programmes obtenus en question 2 (boucle déroulée 4 fois) et 3 (pipeline
logiciel) en utilisant ces super instructions et évaluer le nombre de cycles par itération
d'origine. On supposera le branchement est à effet retardé de 1. Idem pour 3 opérateurs
fonctionnant en parallèle : accès mémoire, opérations flottantes, opérations entières et
branchements.
Pour aller plus loin
Question 6 : processeur superscalaire
Une autre solution pour utiliser le parallélisme offert par la partie opérative est de laisser le
processeur décider si 2 instructions en séquence peuvent être exécutées en parallèle :
l’avantage par rapport au processeur VLIW est que le même programme écrit pour un
processeur classique peut être exécuté sur différents processeurs présentant plus ou moins de
parallélisme.
Exemple :
Parallèlisme possible : accès mémoire, opérations flottantes, opérations entières et
branchements
Programme (sans dépendances):
LDL F1, 0(R1)
ADDflo F2, F3, F4
SUBflo F5, F6, F7
ADDint R1, R1, 8
Le processeur lit 3 instructions :
LDL F1, 0(R1) ADDflo F2, F3, F4 SUBflo F5, F6, F7
Lancement de LDL et de ADDflo, lecture des 2 instructions suivantes :
SUBflo F5, F6, F7 ADDint R1, R1, 8 instr i