Ensimag 2A

Ensimag 2A
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 nbits, dans laquelle il n’est possible d’écrire (et de lire) que par paquets de nbits, 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 iutilisé pour stocker une ligne dans le répertoire possède une autorisation d’écriture (WERi) qui lui est
Examen d’architecture - 2S page - 1

Ensimag 2A
==
index offsettag
DIO[p-1:0]
DIN[p]
DOUT[p]
OE WE CE
HIT
ADDR[m-1:0]
D[31:0]
WEDx WED0
SDx SD0
IADDR[31:0] IINS[31:0]
DOUT[n-1:p+1]
DIN[n-1:p+1]
FIG. 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éa-
toire, 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’instruc-
tion.
Examen d’architecture - 2S page - 2

Ensimag 2A
On rappelle le pipeline à 5 étages du MIPS vue en cours figure 2. Le but de l’exercice est de préciser les modifica-
tions à apporter pour implanter ces deux nouvelles instructions.
PC
Instruction
memory
Registers
Control
M
u
x
M
u
x
M
u
x
Data
memory
M
u
ALU
x
Instruction
IF/ID
IF/IDWrite
ID/EX.MemRead
PCWrite
ID/EX
EX/MEM
MEM/WB
ID/EX.$rd
0
11
EX
WB
WB
M
Forwarding
unit
Hazard
detection
unit
M
u
x
Mux Mux
ID/EX.$rs
ID/EX.$rt
EX/MEM.$rd
MEM/WB.$rd
ID/EX.$rt
ID/EX.$rt
FIG. 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 3et le registre $2 la valeur 0x10000000. On a les valeurs
suivantes dans les registres et la mémoire :
registre valeur adresse valeur
$3 12 0x10000000 123
$4 15 0x10000004 456
$5 17 0x10000008 789
$6 23 0x1000000C 101
$7 26 0x10000010 121
$8 44 0x10000014 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

Ensimag 2A
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 :
t t + 1 t+ 2 t+ 3 t+ 4 t+ 5 t+ 6 t+ 7 t+ 8
ins0 IF ID EX MEM WB
ins1 IF ID EX MEM WB
ins2 IF ID EX MEM WB
ins3 IF ID EX MEM WB
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.
t t + 1 t+ 2 t+ 3 t+ 4 t+ 5 t+ 6 t+ 7 t+ 8
lmw $3, $2, $1 IF ID EX EX EX MEM WB
ins1 IF ID ID ID EX MEM
ins2 IF IF IF ID EX
ins3 IF ID
Examen d’architecture - 2S page - 4

Ensimag 2A
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 tet des lignes de 32 octets. Le cache de 2ème niveau L2 (128K octets) a un temps d’accès de 5tet
des lignes de 256 octets. Le cache de 3ème niveau (1M octets) a un temps d’accès de 30tet 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 Format des lignes Taux de défauts
4Koctets 32 octets 0,098
128Koctets 256 octets 0,020
1Moctets 2K octets 0,005
Examen d’architecture - 2S page - 5