Ce videoclip produit par l’Ecole Polytechnique Fédérale de Lausanne fait partie de son cours d’introduction à l’information, à la communication, et au calcul. Il s’inscrit dans le 3e module de ce cours qui porte sur le fonctionnement et la sécurité des systèmes informatiques.

Où en sommes-nous ? Technologie des mémoires Hiérarchie de mémoires Concept Objectif Réalisation Lecture Ecriture Gestion LRU Exemple Pourquoi – Localité La logique décrite dans les clips précédents tient la route du point de vue conceptuel. Mais quel impact toute cette logique a-t-elle sur la performance du processeur qui doit régulièrement attendre des accès en mémoire principale? Pour comprendre cela il faut l’illustrer par un exemple d’algorithme concret.

Exemple: Somme des entiers jusqu’à n somme des premiers n entiers entrée : n sortie : m s  0 tant que n > 0 s  s + n n  n – 1 m  s Cet exemple reprend une fois de plus l’algorithme de sommation des N premiers entiers déjà utilisé plusieurs fois dans ce cours.

On va se concentrer sur la boucle somme des premiers n entiers entrée : n sortie : m s  0 tant que n > 0 s  s + n n  n – 1 m  s Plus spécifiquement nous allons nous concentrer sur la boucle TANT QUE de cet algorithme.

Notre ordinateur hypothétique Proc Cache avec 2 blocs Mémoire avec 4 blocs Blocs de 4 mots (Pas de registres dans le processeur) Imaginons exécuter cet algorithme sur un ordinateur doté d’une mémoire cache de 2 blocs et d’une mémoire principale de 4 blocs, ces blocs comportant tous 4 mots. Faisons en passant l’hypothèse que ce processeur ne contient pas de registres car cela compliquerait fort la simulation. cache ? ? mémoire principale 4 8 12

Emplacement hypothétique des données dans la mémoire Proc m @3 n @13 s @14 s et m initialement 0 n initialement 2 Faisons encore les hypothèses que la variable m de l’algorithme est stockée dans le mot no.3 de la mémoire la variable n de l’algorithme est stockée dans le mot no.13 de la mémoire la variable s de l’algorithme est stockée dans le mot no.14 de la mémoire m et s sont initialement nuls, et n vaut initialement 2. cache ? ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache ? ? mémoire principale m=0 n=2 s=0 Tant que n > 0 s  s + n n  n – 1 Quand le processeur entame le traitement de la boucle il doit commencer par tester n dans son UA. cache ? ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc lire @13 cache ? ? mémoire principale m=0 Tant que n > 0 s  s + n n  n – 1 lire @ 13 lire @13 Il donne donc l’ordre de lecture du mot 13. cache ? ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache ? ? mémoire principale m=0 n=2 s=0 lire @13 @13 pas en cache (défaut) Proc Tant que n > 0 s  s + n n  n – 1 Ce mot n’étant pas en cache il cause un défaut de cache. cache ? ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache ? ? charger bloc @12 Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 La cache demande donc de charger le bloc 12 qui contient le mot 13. cache ? ? charger bloc @12 mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle 12 Proc cache ? ? n=2 s=0 mémoire principale Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 Proc Ledit bloc est importé de la mémoire principale. cache ? ? 12 n=2 s=0 mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache 12 n=2 s=0 ? mémoire principale m=0 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 Proc Tant que n > 0 s  s + n n  n – 1 Il est placé dans une entrée libre de la cache. cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc @13 = 2 cache 12 n=2 s=0 ? Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 @13 = 2 Et la valeur 2 de n est renvoyée au processeur. cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc lire @14 cache 12 n=2 s=0 ? Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 lire @14 Le processeur doit ensuite charger s et donc lire le mot 14. cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc @14 = 0 (en cache!) cache 12 n=2 s=0 ? Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 @14 = 0 (en cache!) Ce mot se trouvant déjà en cache il lui put lui être envoyé immédiatement. cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc lire @13 cache 12 n=2 s=0 ? Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache!) retourner 0 lire @13 Le processeur doit ensuite charger n et donc relire le mot 13. cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc @13 = 2 (en cache!) cache 12 n=2 s=0 ? Tant que n > 0 s  s + n n  n – 1 @13 = 2 (en cache!) Ce mot étant en cache il peut lui être renvoyé immédiatement. lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache 12 n=2 s=0 ? mémoire principale m=0 Tant que n > 0 s  s + n n  n – 1 Le processeur additionne ensuite s et n et doit stocker le résultat dans s cache lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc écrire 2 @14 cache 12 n=2 s=2 ? Tant que n > 0 s  s + n n  n – 1 écrire 2 @14 Pour ce faire il donne l’ordre d’écrire 2 dans le mot 14, ce qu’il peut faire sans attendre puisque ce mot est en cache. cache 12 n=2 s=2 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) écrire 2 @14 (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc lire @13 cache 12 n=2 s=2 ? Tant que n > 0 s  s + n n  n – 1 lire @13 Il doit ensuite relire une fois de plus n qui est toujours en cache et donc immédiatement disponible. cache 12 n=2 s=2 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) écrire 2 @14 (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc @13 = 2 cache 12 n=2 s=2 ? Tant que n > 0 s  s + n n  n – 1 @13 = 2 La cache lui renvoie donc la valeur 2. cache 12 n=2 s=2 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) écrire 2 @14 (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc cache 12 n=2 s=2 ? mémoire principale m=0 Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) écrire 2 @14 (en cache) somme n, -1 (2 – 1) Le processeur ajoute alors -1 à 2 et doit stocker le résultat dans n, qui est toujours en cache. cache 12 n=2 s=2 ? mémoire principale 4 8 12 m=0 n=2 s=0

Exécution de la boucle Proc écrire 1 @13 cache 12 n=1 s=2 ? Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) écrire 2 @14 (en cache) somme n, -1 (2 – 1) écrire 1 @ 13 (en cache) écrire 1 @13 n-1 peut donc immédiatement être écrit dans le mot 13. cache 12 n=1 s=2 ? mémoire principale 4 8 12 m=0 n=2 s=0

Combien d’accès à la mémoire et à la cache ? Proc Tant que n > 0 s  s + n n  n – 1 lire @13 @13 pas en cache (défaut) = 1 charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) somme s, n (0 + 2) 5 écrire 2 @14 (en cache) somme n, -1 (2 – 1) écrire 1 @ 13 (en cache) Que constate-t-on grâce à cette simulation? Qu’en fait pour la 1e exécution de la boucle le processeur n’a dû attendre que le temps d’un seul défaut de cache, les 5 autres accès à la mémoire ayant pu être satisfaits séance tenante grâce au fait que le seul défaut de cache a causé l’importation d’un bloc de 4 mots contenant toutes les variables nécessaires à la boucle. cache 12 n=1 s=2 ? mémoire principale 4 8 12 m=0 n=2 s=0

Pour toutes les itérations suivantes de la boucle Proc Tant que n > 0 s  s + n n  n – 1 lire @13 (en cache) charger bloc @12 placer bloc @12 retourner 2 lire @14 (en cache) retourner 0 lire @13 (en cache) 6 accès en cache, 0 défaut de cache somme s, n (0 + 2) écrire 2 @14 (en cache) somme n, -1 (2 – 1) écrire 1 @ 13 (en cache) cache Qui plus est, on voit tout de suite que toutes les variables nécessaires à la boucle sont et resteront dans la cache pour toutes les exécutions suivantes de la boucle. 12 n=1 s=2 ? mémoire principale 4 8 12 m=0 n=2 s=0

Au total Pour un total de 6n accès à la mémoire Proc Pour un total de 6n accès à la mémoire 6n - 1 en cache (à 1ns / accès) 1 défaut de cache => accès en mémoire (à 100ns) Performance totale -> (100 + 6n - 1) ns Pas mal du tout si n est très grand ce qui est le cas normal en pratique Donc au final n exécutions de la boucle causent 6n accès à la mémoire. 1 Mais de ces 6n accès à la mémoire seul le 1er cause un défaut de cache, les 6n-1 accès suivants trouvant toujours leur objectif présent dans la cache. 2 Donc si un accès à la mémoire principale coute 100ns de temps d’attente, et un accès à la cache coute 1 ns … 3 … la boucle totale coute 100 + 6n – 1 ns. Ceci peut être inintéressant pour n=2 mais en pratique les algorithmes et programmes sont conçus pour des boucles qui s’exécutent des centaines voire des milliers de fois ou plus. Si n vaut ne fut-ce que 1000, la boucle totale coute 6099 ns, soit seulement 1.0165 ns/accès, ce qui représente un ralentissement d’à peine 1.65% sur toute la boucle – un bon pari sur LRU! cache 12 n=1 s=2 ? mémoire principale 4 8 12 m=0 n=2 s=0