Caches - Irisa

ESIR
INF-ASE
TD 3
1
Exercice 1
On considère un cache de données de 16 Ko direct-mapped avec des lignes de 64 octets. L’index
du cache est virtuel, ce qui signifie que les adresses vues par le programmeur sont celles utilisées
pour accéder au cache. Soit le morceau de programme suivant :
i n t a [NL ] [ NC ] ;
f o r ( i = 0 ; i <NL ; i ++)
f o r ( j = 0 ; j <NC; j ++)
x = x + a[ i ][ j ];
Pour toute la suite de l’exercice, on fera les suppositions suivantes. On suppose que les variables
i, j, x utilisent des registres. On supposera que l’adresse de début du tableau, &a[0][0], commence
au début d’une ligne de cache.
On rappelle que l’adresse &a[i][j] de l’élément (i,j) du tableau a est égale à &a[0][0]+((i*NC+j)
* 4), et on rappelle qu’un int fait 4 octets.
1.1
Le taux de miss est défini comme le nombre total de miss divisé par le nombre total d’accès.
En supposant NC et NL grands, quel est le taux de miss du cache de données ?
1.2
On considère dans la suite de l’exercice le programme suivant, où, par rapport au programme
précédent, on a interverti les boucles i et j :
i n t a [NL ] [ NC ] ;
f o r ( j = 0 ; j <NC; j ++)
f o r ( i = 0 ; i <NL ; i ++)
x = x + a[ i ][ j ];
Quel est le taux de miss si N L = N C = 256 ?
1.3
Quel est le taux de miss si N L = 256 et N C = 272 ?
1
1.4
Quel est le taux de miss si N L = 2048 et N C = 4 ?
2
Exercice 2
On considère un cache de données direct-mapped de 16 Ko avec des lignes de 64 octets. Le
cache est à index virtuel, write-back, avec allocation sur miss en écriture. On veut exécuter la tâche
ci-dessous :
int a [64][64];
int b [64][64];
f o r ( i = 0 ; i <64; i ++)
f o r ( j = 0 ; j <64; j ++)
a[ i ][ j ] = b[ j ][ i ];
Cependant, les tableaux a et b font chacun exactement la taille du cache et vont donc être en
conflit dans le cache si on exécute le programme tel qu’écrit ci-dessus. Pour qu’il n’y ait pas de
conflit dans le cache, nous effectuons la tâche de la manière suivante :
int
int
int
for
for
for
for
a [64][64];
r [N ] ;
b[64][64];
( i = 0 ; i <32; i ++) f o r ( j = 0 ; j <32; j ++) a [ i ] [ j ] = b [ j ] [ i ] ;
( i = 3 2 ; i <64; i ++) f o r ( j = 3 2 ; j <64; j ++) a [ i ] [ j ] = b [ j ] [ i ] ;
( i = 0 ; i <32; i ++) f o r ( j = 3 2 ; j <64; j ++) a [ i ] [ j ] = b [ j ] [ i ] ;
( i = 3 2 ; i <64; i ++) f o r ( j = 0 ; j <32; j ++) a [ i ] [ j ] = b [ j ] [ i ] ;
Nous avons intercalé entre les déclarations des tableaux a et b un tableau r de N entiers, N
étant inconnu. Le tableau r est situé en mémoire juste après le tableau a et le tableau b est situé
juste après le tableau r.
2.1
Quelle est la plus petite valeur de N qui permette que a et b ne soient pas en conflit dans le
cache ?
2.2
On suppose maintenant que la taille de page mémoire fait 4 Ko. Quelle doit être l’associativité
minimum du cache pour qu’on puisse avoir des tags physiques tout en ayant un index purement
virtuel ?
2.3
En supposant que le cache est 4-way set-associatif avec remplacement LRU (least-recently
used), quelle est la plus petite valeur de N qui évite les conflits dans le cache ?
2