Ensimag 2A

2A
Ensimag
Ensimag 2A
Examen d’Architecture avancée
Filière SLE/ISI, 3 heures, tout documents autorisés.
Notation sur 30 points : choisissez les exercices qui vous conviennent le mieux.
1
Caches (8pts)
On désire implanter le mécanisme de réduction de la pénalité du miss dans les caches à correspondance directe
(direct mapped) appellé Victim Cache, inventé par Norman Jouppi de DEC. Jouppi a prouvé expérimentalement
qu’un « cache des victimes » de 4 lignes réduisait la pénalité des miss de conflits de 20% à 95%.
Le principe est le suivant : lors d’un miss, au lieu d’évincer purement et simplement la ligne du cache, le cache
va la copier dans un tout petit cache totalement associatif. Lors des miss suivants, on va vérifier simultanément à
l’accès cache usuel si l’adresse est dans le répertoire du « cache des victimes ».
– si c’est le cas, on va échanger le contenu de la ligne du cache avec celui de la ligne du « cache des victimes » ;
– si ce n’est pas le cas, le cache va chercher la ligne en mémoire, comme il le fait classiquement.
On fait ce travail sur un cache à correspondance directe (direct mapping), à écriture systématique (write through),
structurés en 64 lignes de 8 mots de 32 bits. La mémoire utilisée pour implanter le cache est une mémoire simple
accès de largeur n bits, dans laquelle il n’est possible d’écrire (et de lire) que par paquets de n bits, les lectures
et les écritures ne pouvant avoir lieu au même cycle. Le signal AP[31 :0] est l’adresse émise par le processeur, le
signal DP[31 :0] est la donnée lue par le processeur, le signal D[31 :0] est la donnée telle que disponible sur le
bus.
On ne s’intéressera dans cet exercice qu’aux lectures.
Le cache initial est réalisé à l’aide d’une seule et unique mémoire, qui contiendra donc à la fois le bit d’invalidation,
le tag et les données, simple accès, c.-à-d. que l’on ne peut pas lire et écrire dedans au même cycle. L’interface est
(reçu signifie signal reçu par la mémoire, fourni signifie signal produit par la mémoire) : DIO[n − 1 :0], donnée
en entrée (reçue), lors d’une écriture et produite (fournie), lors d’une lecture ; ADDR[l −1 :0], adresse de l’action
(lecture ou écriture, reçue) ; OE, lecture de la memoire (reçue). La valeur 1 sur OE provoque l’apparition de la
donnée d’adresse ADDR sur le fil DIO[n − 1 :0] qui y reste tant que OE ne passe pas à zéro ; WE, écriture de la
memoire (reçue). La valeur 1 sur WE provoque l’écriture de DIO[n − 1 :0] dans la case d’adresse ADDR ; CS,
selection de la mémoire (reçue). Le répertoire et les données ne peuvent être lus ou écrits indépendamment l’un
de l’autre.
La figure 1 représente la structure du chemin de données du cache proposé avant l’insertion du « cache des
victimes ». On suppose par ailleurs qu’il y a une machine d’état qui contrôle le cache. Dans les questions qui
suivent, on sera amené à modifier des parties de ce schéma en ajoutant du matériel. On vous demande de
redessiner succinctement les parties concernées sur votre feuille d’examen et d’utiliser les noms d’entrées/sorties
spécifiés.
Question 1 Donnez la capacité du cache initial en kilobytes, du point de vue des données.
Question 2 Donnez la structure de l’adresse du point de vue du cache (nombre de bits de chacun des champs).
Question 3 Précisez la largeur n (en nombre de bits) des bus de données de la mémoire utilisée pour réaliser la
totalité du cache (répertoire + données)
On cherche à construire le schéma du chemin de données d’un cache totalement associatif de 4 lignes de 8 mots
de 32 bits, en utilisant une mémoire pour contenir les données, le répertoire étant réalisé en registres (comme le
cache totalement associatif vu en cours et en TD). On notera avec les noms suivants les signaux de cette RAM :
VDIN[p − 1 :0], donnée en entrée (reçue), lors d’une écriture ; VDOUT[p − 1 :0], donnée en sortie (fournie),
lors d’une lecture ; VADDR, adresse de l’action (lecture ou écriture, reçue) ; VOE, lecture des données du cache
(reçue) ; VWE, écriture des données dans la mémoire (reçue) ; VCS, sélection de la mémoire (reçue). Chaque
registre i utilisé pour stocker une ligne dans le répertoire possède une autorisation d’écriture (WERi ) qui lui est
Examen d’architecture - 2S
page - 1
2A
Ensimag
IADDR[31:0]
tag
index
D[31:0]
offset
IINS[31:0]
ADDR[m-1:0]
DIN[n-1:p+1]
SDx
SD0
WEDx
WED0
DIN[p]
OE WE CE
DOUT[p]
DOUT[n-1:p+1]
DIO[p-1:0]
HIT
==
F IG . 1 – Structure du chemin de données du cache
propre. Les 2 questions suivantes doivent être faites sur le même schéma. Elles ne sont séparées que pour mettre
en évidence les 2 parties à réaliser.
Question 4 Donnez la taille du registre contenant le tag du « cache des victimes ». Donnez le schéma de la partie
lecture du cache, en précisant le calcul du signal VHIT qui indique que l’adresse émise par le processeur se trouve dans
ce cache.
Question 5 Ajoutez sur votre schéma la partie écriture du cache. On utilisera une politique de remplacement aléatoire, l’adresse de la ligne à remplacer étant issue d’un compteur modulo 4 tournant en permanence.
On cherche à présent à implanter la partie chemin de données du mécanisme d’échange de lignes, qui va échanger
une ligne du cache « normal » avec une ligne du cache des victimes prise au hasard (on ignore les problèmes
d’initialisation ici, en supposant que les lignes sont déjà toutes utilisées).
Question 6 Précisez et justifiez en 2 lignes le principe de l’échange que vous aller mettre en œuvre.
Donnez un schéma bloc (il n’est pas utile de préciser de nouveau tout ce que vous avez détaillé avant) intégrant les
nouvelles ressources ajoutées pour effectuer cet échange. On pourra se permettre de modifier le « cache normal » si
cela s’avère nécessaire.
Proposez une ébauche d’automate d’état qui pilote les chemins de données pour l’échange.
2
Processeur RISC (9pts)
On désire ajouter au MIPS R3000 les instructions de format R load multiple words, lmw $rt, $rs, $rd, et store
multiple words, smw $rt, $rs, $rd. Ces instructions sont interprétées comme suit : Lmw lit $rd modulo 32 mots
successifs de la mémoire à partir de l’adresse contenue dans le registre $rs dans le registre $rt et ses $rd modulo
32 successeurs eux même modulo 32. Cela signifie que l’on chargera au plus 32 registres, et que si l’on doit
charger une valeur après avoir chargé $31, on devra la charger dans $0. Le registre $rd reste inchangé à la fin de
l’instruction, sauf s’il a été lui même chargé.
Smw écrit $rd modulo 32 registres successifs à partir du registre $rt et de ses $rd modulo 32 successeurs eux
mêmes modulo 32 en mémoire en tant que mots à partir de l’adresse contenue dans le registre $rs. Cela signifie
que l’on écrira au plus 32 registres, et que si l’on doit écrire un registre après $31, ce sera le registre $0.
En sortie de ces instructions, le contenu du registre $rs est inchangé, sauf s’il a été lui même chargé par l’instruction.
Examen d’architecture - 2S
page - 2
2A
Ensimag
On rappelle le pipeline à 5 étages du MIPS vue en cours figure 2. Le but de l’exercice est de préciser les modifications à apporter pour implanter ces deux nouvelles instructions.
Hazard
detection
unit
ID/EX.MemRead
IF/IDWrite
ID/EX
11
Control
0
ALU
ID/EX.$rs
ID/EX.$rt
ID/EX.$rt
ID/EX.$rd
WB
MEM/WB
M
WB
M
u
x
Registers
Mux
Instruction
memory
Instruction
PC
EX
Mux
PCWrite
IF/ID
EX/MEM
M
u
x
Data
memory
M
u
x
M
u
x
EX/MEM.$rd
Forwarding
unit
ID/EX.$rt
M
u
x
MEM/WB.$rd
F IG . 2 – Le pipeline à 5 étages du MIPS avec sa forwarding unit pour utiliser les valeurs contenues dans les
registres du pipeline et sa hazard detection unit pour insérer les bulles.
Question 7 On suppose que le registre $1 contient la valeur 3 et le registre $2 la valeur 0x10000000. On a les valeurs
suivantes dans les registres et la mémoire :
registre
$3
$4
$5
$6
$7
$8
valeur
12
15
17
23
26
44
adresse
0x10000000
0x10000004
0x10000008
0x1000000C
0x10000010
0x10000014
valeur
123
456
789
101
121
314
Donnez le résultat de l’exécution de l’instruction lmw $3, $2, $1 à partir de l’état défini dans la table.
$3 ← 123
$4 ← 456
$5 ← 789
Question 8 Donnez, sous la forme de pseudo-code, l’« algorithme » à exécuter pour effectuer les instructions
lmw $rt, $rs, $rd et smw $rt, $rs, $rd.
On notera $rx le numéro de registre sur 5 bits et rx la valeur du registre sur 32 bits, et RF[$rx] l’accès au registre
$rx dans le banc de registre et MEM[addr] l’accès à la case mémoire d’adresse addr.
Attention, la valeur des registres rs et rd ne changeant pas, il faut faire une copie des valeurs dans des variables
avant de les utiliser si l’on souhaite les modifier. De même, les numéros de registres restent les mêmes à la fin de
Examen d’architecture - 2S
page - 3
2A
Ensimag
l’exécution.
Le load :
nbregs = rd%32
while (--nbregs >= 0) {
RF[($rt+nbregs)%32] = MEM[rs+nbregs*4];
}
Le store :
nbregs = rd%32
while (--nbregs >= 0) {
MEM[rs+nbregs*4] = RF[($rt+nbregs)%32];
}
Question 9 Nous allons maintenant étudier l’impact de l’ajout de ces instructions sur les ressources (composants) du
chemin de données, sans pour l’instant regarder le pipeline.
– Quelle modification faut-il apporter au banc de registre (étage ID - Décode) ? Justifiez votre réponse.
– Faut-il ajouter un ou plusieurs opérateurs dans l’étage EXE ? Si oui lesquels, et pour des opérandes de quelle taille ?
Justifiez votre réponse en analysant les adresses et les index de registres qui doivent être générés durant l’exécution
de l’opération.
RF : 1 port de plus en lecture (32 bits) à cause du store
ALU : on va utiliser l’alu usuelle pour le calcul de l’adresse effective, il faut donc un additionneur 5 bits pour
calculer le numéro de registre et un soustracteur sur 6 bits pour décrémenter le nombre de registre : ceci permet
de faire un test de fin avec uniquement le bit de signe.
Question 10 On reprend l’instruction lmw $3, $2, $1 avec dans $1 la valeur 3. Précisez comment va se dérouler
l’exécution d’une telle instruction en remplissant une table du type :
ins0
ins1
ins2
ins3
t
IF
t+1
ID
IF
t+2
EX
ID
IF
t+3
MEM
EX
ID
IF
t+4
WB
MEM
EX
ID
t+5
t+6
t+7
WB
MEM
EX
WB
MEM
WB
t+8
Attention, comme on va itérer sur une partie du pipeline, la structure de la table sera différente, et on notera "BULLE"
la présence d’une bulle dans le pipeline.
On prend à présent l’instruction smw $3, $2, $1 avec dans $1 toujours la valeur 3. En quoi est-ce différent ?
L’instruction lmw va devoir itérer au plus tard dans l’étage EX et produire autant d’instructions dans la suite du
pipeline qu’il y a d’itérations à faire. Ces mini-instructions vont s’exécuter normalement dans la suite du pipeline,
aussi il y aura autant d’exécution de MEM et WB que de EX.
lmw $3, $2, $1
ins1
ins2
ins3
Examen d’architecture - 2S
t
IF
t+1
ID
IF
t+2
EX
ID
IF
t+3
EX
ID
IF
t+4
EX
ID
IF
t+5
MEM
EX
ID
IF
t+6
WB
MEM
EX
ID
t+7
t+8
page - 4
2A
Ensimag
Le store doit lire les bons registres à chaque nouveau cycle, donc l’accès au banc de registre ne peut plus se faire
comme avant.
Question 11
1. Que faut-il ajouter à la "Hazard Detection Unit" pour exécuter correctement (c’est à dire patienter
jusqu’à ce qu’elles soient achevées) ces nouvelles instructions ? On utilisera la notation ID/EX.qqchose pour
indiquer les informations dont on a besoin dans le registre du pipeline.
2. Que faut-il ajouter à l’étage ID ? Modifiez le schéma de cet étage pour ajouter le matériel nécessaire.
3. Que faut-il ajouter à l’étage EX ? Modifiez le schéma de cet étage pour ajouter le matériel nécessaire.
1. Il faut ajouter la détection de ces instructions spécifiquement, avec une fonction booléenne sur le fait que le
nombre de registres à traiter est différent de zéro. ID/EX.MemMW == 1 && ID/EX.nbregs >= 0
2. Le fil $rt (registre lu) doit être multiplexé avec le résultat de l’addition du registre ID/EX.$rt
et de ID/EX.nbregs. La commande du mux est également issue de l’étage EX et est
ID/EX.MemSMW == 1 && ID/EX.nbregs >= 0
Une troisième entrée de lecture doit également être ajoutée (banc de registre à 3 lectures simultanées) afin
de pouvoir lire 3 registres dans le cas du store.
3. Il faut ajouter un adder et un substractor et faire les bonnes connections. Il faut amener rs+nbregs*4 en
entrée de l’ALU pour fournir le calcul d’adresse.
3
Hiérarchie de caches (6pts)
Pour pallier à la différence de rapidité entre processeur et mémoire centrale, il est possible d’utiliser plusieurs
niveaux de caches. Nous étudierons ici une organisation à 3 niveaux de cache :
Le processeur est un processeur 32 bits et a un temps de cycle de t. Le cache de 1er niveau L1 (4K octets) a un
temps d’accès t et des lignes de 32 octets. Le cache de 2ème niveau L2 (128K octets) a un temps d’accès de 5t et
des lignes de 256 octets. Le cache de 3ème niveau (1M octets) a un temps d’accès de 30t et des lignes de 2048
octets. Le temps d’accès à la mémoire centrale est de 60t. On supposera que le temps de pénalité en cas de défaut
dans un cache est égal au temps d’accès au niveau suivant de la hiérarchie de mémoire.
Question 12 Évaluation du temps moyen d’accès.
Par simulation, on a évalué les taux de défauts pour des caches de premier niveau :
Taille du cache
4Koctets
128Koctets
1Moctets
Examen d’architecture - 2S
Format des lignes
32 octets
256 octets
2K octets
Taux de défauts
0,098
0,020
0,005
page - 5
2A
Ensimag
On définit :
– le taux de défauts local d’un cache par : nombre de défauts lors de l’accès à ce cache divisé par le nombre d’accès à
ce cache ;
– le taux de défauts global d’un cache par : nombre de défauts lors de l’accès à ce cache divisé par le nombre total
d’accès mémoire demandé par le processeur.
1. calculez les taux de défauts locaux et globaux des 3 caches ;
2. calculez le temps moyen d’accès à une donnée pour le processeur.
Question 13 Évaluation analytique du temps d’exécution d’un programme.
On considère le programme suivant, qui ajoute une valeur constante (mémorisée dans R1) à tous les éléments d’un
tableau T de dimension 1000, un élément étant codé sur 32 bits. Le code est en pseudo-assembleur proche du MIPS,
la sémantique des instructions est précisée en commentaire.
boucle:
LD #1000, R2
LD #T, R3
LD 0(R3), R4
ADD R4, R1, R4
ST R4,0(R3)
ADD R3,#4,R3
SUB R2,#1,R2
BNZ R2,boucle
!
!
!
!
!
!
!
!
Charge la constante 1000 dans R2
Charge l’adresse du tableau T dans R3
Charge la valeur à l’adresse R3+0 dans R4
Ajoute R1 et R1 et met le resultat en R4
Stocke R4 à l’adresse R3+0
Ajoute la constante 4 à R3
Ajoute la constante 1 à R2
Saute à boucle si R2 est différent de 0
Le processeur est pipe-line, avec lancement possible d’une instruction à chaque période d’horloge. Si on veut faire des
calculs très détaillés, on doit prendre en compte le fait qu’un cycle d’attente doit être inséré après un LD (si il y a
dépendance) et après un saut. On suppose que le tableau T est mémorisé en mémoire centrale avant l’exécution de
cette itération (aucune partie de ce tableau n’a été recopiée dans un cache).
– Combien de périodes d’horloge seront- elles nécessaires à l’exécution de ce programme avec la hiérarchie de 3 caches
définie ci-dessus ?
4
Réordonnancement de programmes (7pts)
On s’intéresse ici à la réorganisation statique et dynamique d’un fragment de programme, implémentant le calcul
suivant sur un tableau de nombre réels (codés en flottant) :
tant que T(i+1) != 0 faire début T(i) := T(i) + T(i+1); i := i+2; fin;
Le processeur utilisé est caractérisé par :
formats :
mot mémoire de 32 bits, adresses 32 bits, adressage à l’octet,
traitant des entiers codés sur 32 bits et des flottants (réels) codés sur 64 bits
registres :
16 registres pour valeurs entières R0, ..., R15
16 registres pour valeurs codées en flottant : F0, ..., F15
modes
registre
d’adressage :
valeur immédiate #vi
indexé par rapport à un registre Ri : depl(Ri)
relatif au compteur programme pour les branchements
jeu
LDW depl(Rj), Ri
Ri := Mém(Rj+depl)
d’instructions :
LDL depl(Rj), Fi
Fi := Mém(Rj+depl)
(utiles pour le sujet) STW Ri, depl(Rj)
Mém(Rj+depl) := Ri
STL Fi, depl(Rj)
Mém(Rj+depl) := Fi
OPint Ri,Rj,Rk
Rk := Ri OPint Rj
OPflo Fi,Fj,Fk
Fk := Fj OPflo Fj
CMPI Ri, Rj, CCR
CCR := f (Ri,Rj)
CMPF Fi,Fj, CCR
CCR := g(Fi,Fj)
BIcc étiq
branchement à étiq si condition (positionnée par CMPI) vraie
BFcc étiq
branchement à étiq si condition (positionnée par CMPF) vraie
Examen d’architecture - 2S
page - 6
2A
Ensimag
Dans les instructions OPint, et CMPI (ou OPflo et CMPF), le registre Rj (ou Fj) peut être remplacé par une valeur
immédiate. On remarque qu’il y a positionnement explicite du registre code condition CCR par les instructions
CMPI (comparaison d’entiers) et CMPF(comparaison de flottants). Les autres instructions ne modifient pas CCR.
On distingue les instructions de branchement conditionnel suivant le type de condition testée.
En supposant que R12 contient l’adresse de T(i), le fragment de programme ci-dessus peut être traduit par :
1 boucle :
2
3
4
5
6
8
9
10 suite :
LDL
8(R12),F2
CMPF
F2,#0,CCR
BFZ suite
LDL
0(R12),F1
ADDF
F1,F2,F1
STL
F1,0(R12)
ADDI
R12,#16,R12
BRA boucle
!
!
!
!
!
!
lecture T(i+1)
comparaison à 0
branchement à la suite si T(i+1) = 0
lecture T(i)
calcul
et stockage du résultat
Ce processeur est pipe-line, et la table ci-dessous indique les cycles d’attente en cas de dépendance : Remarque :
ce processeur est à prédiction de branchement. Quand la prédiction est réalisée pour un branchement déjà rencontré, le temps d’attente est 0 (l’adresse cible du branchement est disponible) et il est inutile d’attendre la fin
d’une comparaison CMPF. Quand la prédiction n’est pas réalisée et/ou c’est la première fois qu’on rencontre ce
branchement, le temps perdu est de 2 pour un BIcc, de 4 pour un BFcc (temps entre l’opération CMPF et l’opération de branchement = 2 inclus). Vous pourrez vous contenter d’analyser le comportement du programme pour
une prédiction réalisée et une adresse cible connue, le branchement BFZ n’étant effectué qu’en fin d’itération.
1ère instruction
instruction dépendante
LDW
LDL
STW
STL
OPint ou CMPI
OPflo ou CMPF
BIcc
BFcc
LDW
LDL
STW
STL
OPint
OPflo
CMPI
CMPF
BIcc
BFcc
1
1
1
1
1
-
3
3
-
-
-
0
0
0
0
0
-
3
3
-
0
-
2
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Question 14
1. évaluez le nombre de cycles par itération du programme indiqué ci-dessus.
2. modifiez le programme pour diminuer le nombre de cycles
3. déroulez la boucle (3 exemplaires devraient être suffisants) et optimisez le programme obtenu ; à noter : il est
nécessaire de modifier les registres utilisés (renommage statique)
4. supposons qu’on dispose de 3 registres CCR : CCR1, CCR2, CCR3 : peut-on optimiser le programme obtenu en
précédemment (item 3) ?
5. on transforme le processeur en processeur VLIW, avec deux pipe-lines fonctionnant en parallèle (donc 2 opérations par instruction VLIW) : le premier pipe-line peut exécuter des opérations entières ou flottantes (y compris
les comparaisons), le deuxième des opérations entières ou un accès mémoire. Il n’y a pas de parallélisme possible
avec une instruction de branchement. Proposez un programme optimisé pour un tel processeur, en supposant
que quand un registre est à la fois source et destination dans une même instruction VLIW, sa valeur avant
l’exécution de toute opération de l’instruction VLIW est prise comme opérande.
6. on transforme le processeur en processeur superscalaire, capable d’examiner et de lancer (si possible) plusieurs
instructions en parallèle : dans le cas où il s’agit de 2 instructions successives, proposez une version optimisée
du programme.
Examen d’architecture - 2S
page - 7