CEG 3556: Conception Avancée de Systèmes

Informatiques (Hiver 2022)

Prof. Rami Abielmona
Solutions Potentielles pour Devoir #4: Pipeline
et Hierarchie de Mémoire

7 Mars, 2022

Question I
Cette question ce concerne avec les schémas de forwarding tout en résolvant les
risques de données dans les implémentations de processeur en pipeline.

Cette solution vérifie pour la combination de lw-sw quand l’instruction

de lw est dans l’étape de MEM et l’instruction sw est dans l’étape
de EX.

if (ID/EX.MemWrite and // sw dans l’etape de EX ?

EX/MEM.MemRead and // lw dans l’etape de MEM ?
(ID/EX.RegisterRt = EX/MEM.RegisterRd) and // meme registre ?
(EX/MEM.RegisterRd != 0)) // mais pas r0 ?
then
Mux = 1 // forward la valeur de lw
else
Mux = 0 // ne pas forwarder

Cette solution vérifie pour la combination de lw-sw quand l’instruction

de lw est dans l’étape de WB et l’instruction sw est dans l’étape de
MEM.

if (EX/MEM.MemWrite and // sw dans l’etape de MEM ?

(MEM/WB.MemtoReg = 1) and MEM/WB.RegWrite and // lw dans l’etape de WB ?
(EX/MEM.RegisterRd = MEM/WBRegisterRd) and // meme registre ?
(MEM/WB.RegisterRd != 0)) // mais pas r0 ?
then
Mux = 1 // forward la valeur de lw

1
 Figure 1: EX stage and MEM stage check

else
Mux = 0 // ne pas forwarder

Pour que cette solution fonctionne, nous devrons faire un petite

modification sur le hardware: nous devons ^ etre capable de vérifier
si le registre de source pour sw (rt ) est le m^ eme que le registre de
destination pour lw (comme dans la solution précédente). Cependant,
le registre de source pour sw n’est pas nécessairement disponible dans
l’étape de MEM. Ce est facile d’y remédier: comme il est maintenant,
le réglage de RegDst pour sw est X,ou "don’t care" (reportez-vous à
la Figure 4.49 sur la page 360). Rappelez-vous que RegDst choisit
si rt ou rd est le registre de destination d’une instruction. Depuis
que cette valeur n’est jamais utilisé par un sw, nous pouvons faire
ce que nous voulons avec - alors laissez-nous toujours choisir rt.
Cela garantit que le registre de source d’un sw sera disponible pour

2
 Figure 2: MEM stage and WB stage check

les équations ci-dessus dans l’étape de MEM (rt sera dans EX/MEM.WriteRegister ).
(See Figure 4.51 on page 304).
Un stall de lw-sw peut peut ^etre évité si le registre de décalage
(offset register) pour sw (rs ) n’est pas le registre de destination
pour lw, ou si le registre de destination pour lw est r0.

if ID/EX.MemRead and // lw dans l’etape de EX ?

((ID/EX.RegisterRt = IF/ID.RegisterRs) or // meme registre ?
(ID/EX.RegisterRt = IF/ID.RegisterRt)) and // mais pas...
not (IF/ID.MemWrite and // sw dans l’etape de ID ?
(ID/EX.RegisterRt = If/ID.RegisterRs)) and // meme registre ?
(MEM/WB.RegisterRd != 0)) // mais pas r0 ?
then
Stall the pipeline

Notez que IF/ID.MemWrite est un nouveau signale qui signifiant une

3
instruction de stockage. Ceci doit ^ etre décodé à partir du opcode.
La vérification que le registre de destination pour lw n’est pas r0
n’est pas fait dans la formule de stall sur la page 314, qui ne cause
pas de problème. Le compilateur peut ^etre conçu pour ne jamais émettre
de code pour charger registre r0, ou d’accepter un stall inutile, ou
le check peut ^etre ajouter, comme il est fait ici.

Question II
Cette question ce concerne avec les hasards de branchement dans les processeurs
pipelined.

Partie a
Flushing a lieu après une branche est prise. Stalling a lieu si une
dependence ne peut pas e ^tre résolu utilisant forwarding (si une instruction
de lw est dans l’étape de EX, une instruction avec une dependence précédente
doit ^etre staller pour un cycle). Si nous supposons qu’une résolution
de branchement prend place dans l’étape de MEM, puis pour l’exemple
de code, dans le quatrième cycle d’exécution nous avons exactement
cette situation. L’instruction de beq nécessitera un flush des trois
instructions de lw, add et sw, et l’instruction de lw nécessitera un
stall des instructions add et sw. Coopération aura lieu concernant
les signaux de contr^ ole de mise à zéro. Cependant, un conflit qui
se pose est de savoir si le PC doit ^ etre écrit (flush dit oui, stall
dit non). Le flush devrait avoir la priorité (une solution proposée
à ce problème est de changer l’unité de détection de hasard sorte que
quand il regarde le signal de RegWrite a l’étape de EX, il voit le
signal après qu’il passe par le MUX utilisé pour flusher le pipeline).

Partie b
Reqardez a la Figure 4.65 sur la page 325. Le contr^ ole dans ID doit
etre augmenter pour produire un signale indicant que l’instruction
^
dans ID est beq. L’égalité des valeurs de registre est détecté en
utilisant une banque de portes XNOR. PCSrc est alors généré dans ID,
qui prend la décision de branchement dans ID et réduit les retards
de branchement à une seule instruction.

Question III
Cette question ce concerne avec les schémas d’implémentations de cache.

4
 Figure 3: XNOR-based comparator design

Partie a
La table 1 nous montre la liste de référence de hit/miss et le contenu
final du cache.

Partie b
La table 2 nous montre la liste de référence de hit/miss et le contenu
final du cache, avec l’ordre de LRU montré de de droite à gauche.

Partie c
La table 3 nous montre la liste de référence de hit/miss et le contenu
final du cache (notez que bloc #0 représente le plus récemment utilisé,
et bloc #15 représente le moins récemment utilisé).

Question IV
Cette question ce concerne avec l’analyse de la mémoire virtuelle.

La taille totale est égal au nombre d’entrées fois la taille de chaque

entrée. Le nombre d’entrées est égal au nombre de pages à l’adresse
virtuelle, qui est

240 bytes 240 bytes

= 4 10 = 226 (1)
16KB 2 2 bytes

5
 Reference Hit ou miss Bloc # Adresse
1 Miss 0
4 Miss 1 17
8 Miss 2
5 Miss 3 19
20 Miss 4 4
17 Miss 5 5
19 Miss 6 6
56 Miss 7
9 Miss 8 56
11 Miss 9 9
4 Miss 10
43 Miss 11 43
5 Hit 12
6 Miss 13
9 Hit 14
17 Hit 15

Table 1: Cache analysis

La largeur de chaque entrée est idéalement 4 + (36 - 14) bits =

26 bits. Ainsi, le tableau de la page contient 226 ∗26 = 218103808
bytes. Toutefois, la largeur réelle de chaque entrée sera de 32 bits
pour la facilité de l’indexation. Ainsi, le tableau de la page contiendrait
228 bytes ou 256 MB. Les 6 bits supplémentaires (32-26) seront utilisés
pour stocker des informations supplémentaires qui doit ^etre maintenu
sur une base par page. Les deux réponses sont acceptables.

Question de Boni
Cette question ce concerne avec le déroulement des boucles des processeur su-
perscalaire.

Partie a
Le code a été déroulé une fois et les registres ont été renommés. La
question est simplement comment de reprogrammer le code pour une performance
optimale. Il ya beaucoup de solutions possibles, dont l’un est:

Loop: lw $t0, 0($s1)

lw $t1, -4($s1)
addu $t0, $t0, $s2
addu $t1, $t1, $s2
sw $t0, 0($s1)

6
 Reference Hit or miss
1 Miss
4 Miss
8 Miss
5 Miss Bloc # élément #1 adresse élément #1 adresse
20 Miss 0 56 8
17 Miss 1 17 9
19 Miss 2
56 Miss 3 43 11
9 Miss 4 4 20
11 Miss 5 5
4 Hit 6 6
43 Miss 7
5 Hit
6 Miss
9 Hit
17 Hit

Table 2: Cache analysis

sw $t1, -4($s1)
addi $s1, $s1, -8
bne $s1, $zero, Loop

En ce qui concerne la performance, supposons que $s1 est initialement

8X. Le code exigera X itérations et un total de 11X cycles pour exécuter
en supposant que les résolutions de branchement sont complets dans
l’étape de MEM. Si la résolution de branchement se fait à l’étape de
ID, la totalité des cycles à exécuter seraient 9X. Si le code n’est
pas déroulé (comme à la page 337), il faudra 2X itérations et terminer
sur le cycle (2X) * 9 (en supposant un stall d’un cycle après le load).
Donc, dans ce cas, le déroulement nous donne une amélioration de 18/11
= 1.64 fois plus vite.

Partie b
Premièrement, nous pouvons dérouler la boucle deux fois et de le reporter,
en supposant que $s1 est un multiple de 12:

Loop: lw $t0, 0($s1)

lw $t1, -4($s1)
lw $t1, -8($s1)
addu $t0, $t0, $s2
addu $t1, $t1, $s2
addu $t2, $t2, $s2

7
 Reference Hit or miss Bloc # Adresse
1 Miss 0 17
4 Miss 1 9
8 Miss 2 6
5 Miss 3 5
20 Miss 4 43
17 Miss 5 4
19 Miss 6 11
56 Miss 7 56
9 Miss 8 16
11 Miss 9 20
4 Hit 10 8
43 Miss 11 1
5 Hit 12
6 Miss 13
9 Hit 14
17 Hit 15

Table 3: Cache analysis

sw $t0, 0($s1)
sw $t1, -4($s1)
sw $t2, -8($s1)
addi $s1, $s1, -12
bne $s1, $zero, Loop

Il ya plusieurs façons de modifier ce code afin qu’il fonctionne

toujours correctement si $s2 n’est pas un multiple de 12. Probablement,
la meilleure méthode consiste à déterminer $s2 mod 12 avant d’exécuter
la boucle. Une des solutions les plus simples appara^ ıt ci-dessous.
Dans ce cas, nous nous occupons de tout simplement les cas supplémentaires
à la fin, et les détecter en soustrayant 12 de $s1 avant que nous commencions:

Loop: addi $s1, $s1. -12

bltz $s1, Finish
lw $t0, 12($s1)
lw $t1, 8($s1)
lw $t2, 4($s1)
addu $t0, $t0, $s2
addu $t1, $t1, $s2
addu $t2, $t2, $s2
sw $t0, 12($s1)
sw $t1, 8($s1)
sw $t2, 4($s1)
bne $s1, $zero, Loop

8
 j Done
Finish: lw $t0, 12($s1) # $s1 peut \^{e}tre -4 ou -8
addu $t0, $t0, $s2 # Cela g\‘{e}re 8 (si -4) ou 4 (si -8)
sw $t0, 12($s1)
addi $s1, $s1, 4 # $s1 est maintenant 0 ou -4
bne $s1, $zero, Done # si $s1 n’est pas 0, est entr\’{e} \‘{a} -8
lw $t0, 4($s1)
addu $t0, $t0, $s2
sw $t0, 4($s1)
Done: ...

Remerciements
Les réponses et figures liés aux questions de livres scolaires sont tirées avec le
manuel de professeur Computer Organization and Design, quatrième edition,
par Patterson et Hennessy.