Ce videoclip produit par l’Ecole Polytechnique Fédérale de Lausanne

Présentation au sujet: "Ce videoclip produit par l’Ecole Polytechnique Fédérale de Lausanne"— Transcription de la présentation:

1 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.

2 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.

3 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.

4 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.

5 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

6 Emplacement hypothétique des données dans la mémoire
Proc 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

7 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

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

9 Exécution de la boucle Proc cache ? ? mémoire principale m=0 n=2 s=0
@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

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

11 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 @13 pas en cache (défaut) charger 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

12 Exécution de la boucle Proc cache 12 n=2 s=0 ? mémoire principale m=0
@13 pas en cache (défaut) charger placer 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

13 Exécution de la boucle Proc @13 = 2 cache 12 n=2 s=0 ?
Tant que n > 0 s  s + n n  n – 1 @13 pas en cache (défaut) charger placer 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

14 Exécution de la boucle Proc lire @14 cache 12 n=2 s=0 ?
Tant que n > 0 s  s + n n  n – 1 @13 pas en cache (défaut) charger placer retourner 2 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

15 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 @13 pas en cache (défaut) charger placer retourner 2 (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

16 Exécution de la boucle Proc lire @13 cache 12 n=2 s=0 ?
Tant que n > 0 s  s + n n  n – 1 @13 pas en cache (défaut) charger placer retourner 2 (en cache!) retourner 0 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

17 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. @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) cache 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

18 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) 12 n=2 s=0 ? mémoire principale 4 8 12 m=0 n=2 s=0

19 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 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) écrire (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

20 Exécution de la boucle Proc lire @13 cache 12 n=2 s=2 ?
Tant que n > 0 s  s + n n  n – 1 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) écrire (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

21 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) écrire (en cache) ? mémoire principale 4 8 12 m=0 n=2 s=0

22 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) écrire (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

23 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 @13 pas en cache (défaut) charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) écrire (en cache) somme n, -1 (2 – 1) écrire 13 (en cache) écrire 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

24 Combien d’accès à la mémoire et à la cache ?
Proc Tant que n > 0 s  s + n n  n – 1 @13 pas en cache (défaut) = 1 charger placer retourner 2 (en cache) retourner 0 (en cache) somme s, n (0 + 2) 5 écrire (en cache) somme n, -1 (2 – 1) écrire 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

25 Pour toutes les itérations suivantes de la boucle
Proc Tant que n > 0 s  s + n n  n – 1 (en cache) charger placer retourner 2 (en cache) retourner 0 (en cache) 6 accès en cache, 0 défaut de cache somme s, n (0 + 2) écrire (en cache) somme n, -1 (2 – 1) écrire 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

26 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 -> ( n - 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 n – 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 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