Cours "Architecture des Systèmes Multi-Processeurs"

TP4 : Caractérisation et dimensionnement des caches

(pirouz.bazargan-sabet@…)

A. Objectifs

On cherche dans ce TP à évaluer de façon systématique l'influence de différentes caractéristiques des caches sur le temps d'exécution d'une application logicielle. Les paramètres importants sont la capacité des caches (données et instruction), le nombre de mots par ligne de cache, le nombre de niveaux d'associativité, ainsi que la profondeur du tampon d'écritures postées.

Pour avoir un point de comparaison, on commence par exécuter l'application logicielle sur une architecture possédant des caches de très grande capacité. En effet, quand tout le code binaire exécutable peut résider dans le cache instruction et que toutes les données peuvent être stockées dans le cache de données, le taux de MISS tend vers 0, et on a un système mémoire « presque parfait ».

Malheureusement, la capacités des caches est limitée par deux facteurs physiques:

• d'une part, la surface de silicium occupée par les caches, et donc le coût de fabrication, sont proportionnels à la capacité de stockage.
• d'autre part, le temps d'accès (temps nécessaire pour extraire une donnée du cache) augmente avec la capacité, et ce temps d'accès influence le temps de cycle, et donc la fréquence du processeur.

Il faut donc faire des compromis.

Par ailleurs, on sait que - à capacité égale - un cache associatif par ensembles a un taux de MISS plus faible qu'un cache à correspondance directe. Mais le cache associatif occupe (un peu) plus de surface et est (un peu) plus lent. Ici encore, il faut faire des compromis, et nous allons étudier l'influence des différents paramètres sur les performances.

Pour faciliter la mesure des performances, on utilise l'appel système proctime() du GIET, qui renvoie le contenu d'un compteur de cycles interne au processeur. Ce compteur est initialisé à 0 au démarrage de la simulation.

B. Architecture matérielle

Pour faire ces comparaisons, on utilise la même architecture matérielle que dans les deux TPs précédents (un seul processeur, une RAM, une ROM et un terminal TTY). On choisit une application logicielle écrite en langage C, qui calcule de façon récursive la somme des N premiers nombres entiers, pour N variant entre 0 et 29, et on affiche le résultat du calcul à chaque itération de la boucle principale.

L'archive attachment:multi_tp4.tgz​ contient les fichiers dont vous aurez besoin. Créez un répertoire de travail tp4, et recopiez dans ce répertoire les deux fichiers tp2_top.cpp et tp2.desc décrivant l'architecture matérielle. Décompressez l'archive, et copiez dans tp4 le répertoire soft contenant le fichier main.c (programme C), le fichier reset.s (code de boot), les fichiers sys.ld, app.ld et seg.ld (contrôle de l'édition de liens), et le fichier Makefile (génération du code binaire).

C. Système mémoire presque parfait

Compilez l'application logicielle en lançant le makefile qui vous est fourni dans le répertoire soft pour générer le fichiers sys.bin et app.bin contenant le code binaire.

Compilez le prototype virtuel décrivant l'architecture matérielle, après avoir vérifié que tous les segments autres que les segments seg_tty et seg_kunc sont « cachables » dans la Table des Segments.

Ce prototype virtuel est générique, puisqu'il est possible de modifier les caractéristiques des deux caches, en définissant des valeurs de paramètres sur la ligne de commande.

Question C1 : Lancez la simulation, avec des caches très grands : 256 sets, 16 mots par ligne, et 4 niveaux d'associativité soit une capacité de 64 Koctets pour chacun des deux caches. On choisit également un tampon d'écritures postées de profondeur 8 mots de 32 bits. Quel est le temps d'exécution de l'application?

Le modèle SystemC du composant matériel !PibusMips32Xcache possède des pseudo-registres utilisés pour faire de l'instrumentation non intrusive: Le pseudo-registre c_total_cycles compte le nombre total de cycles exécutés depuis le RESET. Les pseudo-registres c_imiss_count et c_imiss_frz comptent respectivement le nombre total de miss instruction et le nombre total de cycles de gel du processeur dûs aux miss instruction. Ceci permet de mesurer le taux de miss instruction et le coût du miss instruction. Symétriquement, les pseudo-registres c_dmiss_count et c_dmiss_frz fournissent le même service pour le cache de données. On peut également mesurer le nombre moyen de cycles par instruction (CPI), ainsi que le pourcentage d'instructions de lecture de données (cachées ou non-cachées), ou le pourcentage d'instructions d'écriture.

Pour afficher ces statistiques, on peut utiliser l'argument -STATS sur la ligne de commande. Attention: il faut choisir judicieusement la période d'affichage pour que les mesures soient effectuées pendant que le processeur est effectivement actif.

Question C2 : Relancez la simulation, et déterminez les taux de MISS pour le cache instruction et le cache de données ainsi que la valeur du CPI. Les taux de MISS sont-il constants au cours du temps ? Comment évoluent-t-ils au cours des 1000 premiers cycles? Interprêtez ce comportement.

Question C3 : En analysant le contenu des fichiers pibus_mips32_xcache.cpp et pibus_mips32_xcache.h, expliquez comment sont calculés le CPI et les deux taux de MISS.

D. Influence de la capacité du cache instruction

On relance maintenant l'exécution de l'application pour différentes capacités du cache instruction, mais en conservant un gros cache de données de 64 Koctets. On utilise un cache instruction à correspondance directe (-IWAYS 1), et on fait varier le nombre de cases pour les valeurs : 1, 4, 16, 64 et 256, en gardant une largeur fixe de 8 mots par ligne de cache.

-ISETS	-IWORDS	-IWAYS	-DSETS	-DWORDS	-DWAYS
256	8	1	256	16	4
64	8	1	256	16	4
16	8	1	256	16	4
4	8	1	256	16	4
1	8	1	256	16	4

Question D1 : Relevez, pour chaque configuration, la durée d'exécution du programme, le taux de MISS sur le cache instruction, le cout du miss instruction et la valeur du CPI. Comment interprêtez-vous ces résultats ?

Question D2 : Pourquoi la valeur obtenue pour le coût du MISS est-elle différente de la valeur estimée dans le TP3 ? Comment expliquez-vous que le coût du miss puisse avoir une valeur non entière ? Pourquoi tous les MISS nont-ils pas le même coût ?

E. Influence de la largeur de la ligne de cache

On cherche maintenant à évaluer l'influence de la largeur de la ligne de cache, à capacité de stockage constante. On conserve un cache de données de 64 Koctets, et on relance donc l'exécution de l'application pour les 5 configurations suivantes du cache instruction (capacité constante de 1 Koctets) :

-ISETS	-IWORDS	-IWAYS	-DSETS	-DWORDS	-DWAYS
256	1	1	256	16	4
128	2	1	256	16	4
64	4	1	256	16	4
32	8	1	256	16	4
16	16	1	256	16	4
8	32	1	256	16	4

Question E1 : Représenter graphiquement la durée d'exécution du programme en fonction de la largeur de la ligne de cache. Quelle est la configuration la plus efficace ? Comment expliquez-vous ce résultat ?

F. Influence de la capacité du cache de données

Pour ce qui concerne le cache de données, on pourrait de la même façon faire varier séparément la capacité du cache, la largeur de la ligne de cache, et le nombre de niveaux d'associativié. On se contente ici d'étudier l'influence de la capacité du cache de données en continuant à utiliser un gros cache instruction de 64 Koctets. On utilise un cache de données à correspondance directe, des lignes de 8 mots, et on fait varier le nombre de sets.

-ISETS	-IWORDS	-IWAYS	-DSETS	-DWORDS	-DWAYS
256	16	4	256	8	1
256	16	4	64	8	1
256	16	4	16	8	1
256	16	4	4	8	1
256	16	4	1	8	1

Question F1 : Relevez, pour chaque valeur, la durée d'exécution du programme, le taux de MISS sur le cache de données, le cout du miss de données et la valeur du CPI.

G. Influence de la profondeur du tampon d'écritures postées

On étudie enfin l'influence de la profondeur du tampon d'écritures postées. Le paramètre WBUF_DEPTH définit le nombre maximum de requêtes d'écritures (correspondant à des instructions de type sw ou sb) qui peuvent être stockées dans ce tampon.

Question G1 : Comment est réalisé le tampon d'écriture postées ? quelle sont les informations qu'il faut stocker dans le tampon pour chaque requête d'écriture enregistrée ? Que se passe-t-il lorsque le processeur effectue une requête d'écriture alors que le tampon décriture postées est plein? Que se passe-t-il lorsque le processeur fait une requête de lecture (instruction ou donnée) qui fait miss, alors que le tampon d'écriture est non-vide ? Pourquoi ce comportement ?

On conserve un cache instruction et un cache de données de 64 Koctets chacun, et on relance l'exécution de l'application pour différentes profondeurs du tampon d'écritures postées. Le paramètre WBUF représente le nombre maximal de requêtes d'écritures qui peuvent être stockées dans le tampon. On mesurera successivement les temps d'exécution pour des profondeurs de 1, 2, 4, et 8 mots.

Question G2 : Mesurez le temps d'exécution de l'application, le CPI, le coût des écriture, et La fréquence des écritures pour des profondeurs de 1, 2, 4, et 8 mots. À quoi correspond le coût des écritures ? Comment expliquez-vous le fait que le coût des écritures soit si faible ?

H. Compte-rendu

Les réponses aux questions ci-dessus doivent être rédigées sous éditeur de texte et ce compte-rendu doit être rendu au début de la séance de TP suivante. De même, le simulateur, fera l'objet d'un contrôle (par binôme) au début de la séance de TP de la semaine suivante.