# Travail pratique 2 - Cours Microprocesseur
## Configuration du cache
En exécutant la commande: `getconf -a | grep CACHE`, on obtient:
```
LEVEL1_ICACHE_SIZE                 32768
LEVEL1_ICACHE_ASSOC                8
LEVEL1_ICACHE_LINESIZE             64
LEVEL1_DCACHE_SIZE                 32768
LEVEL1_DCACHE_ASSOC                8
LEVEL1_DCACHE_LINESIZE             64
LEVEL2_CACHE_SIZE                  262144
LEVEL2_CACHE_ASSOC                 4
LEVEL2_CACHE_LINESIZE              64
LEVEL3_CACHE_SIZE                  4194304
LEVEL3_CACHE_ASSOC                 16
LEVEL3_CACHE_LINESIZE              64
```
Cela nous donne la configuration pour les cache de niveau 1 (data et code), 2 et 3. Pour chacun, on obtient leur taille complète (SIZE), leur taille de bloc (LINESIZE) et le nombre de bloc se trouvant dans un Set (ASSOC).
## Optimisation (buffer simple)
Afin de trouver les adresses, on execute le programme avec GDB, on met un breakpoint sur le main et on exécute. Ici, nous pouvons faire:
```
(gdb) print &x[0][0]
$1 = (int *) 0x7fffffe15540
(gdb) print &x[0][1]
$2 = (int *) 0x7fffffe15544
(gdb) print &x[0][2]
$3 = (int *) 0x7fffffe15548
(gdb) print &x[1][0]
$4 = (int *) 0x7fffffe156d0
```
On voit clairement que les cellules [0][0] et [0][1] sont voisines avec un offset de 4 (c'est des integer). La cellule [1][0] se trouve 400 lignes plus loin (donc 100 cellules de différences) si l'on fait le calcul:
```
Hex value:
7fffffe156d0 – 7fffffe15540 = 190

Decimal value:
140737486345936 – 140737486345536 = 400
```
D'après la théorie vue en cours, il est préférable de parcourir le tableau dans l'ordre où les cellules sont stocké dans la RAM car on déplace les données par bloc de 64. Du coup, on change tout le temps les données avec la mauvaise façon.\
Si l'on fait le calcul de performances (exécution du programme avec les deux méthodes), on obtient:
```
Bad method
Time 0.002857 seconds
Good method
Time 0.002001 seconds
```

Cette différence vient du problème de la data locality. Lorsque nous parcourons le tableau selon le deuxième index, celui-ci fait des sauts dans la mémoire pour atteindre les différents éléments, ce qui n'est pas très bon pour profiter du cache.

Cependant dans la bonne version, celui-ci parcours en premier le premier index et ensuite le deuxième. Il accède à des données qui sont à suivre dans la mémoire.

## Optimisation (buffer complexe)
Cette partie porte sur l'optimisation liées aux alignements dans la mémoire.\
Par défaut, sur une machine x86, l'alignement est de 4.