Fonctionnement d'un ordinateur depuis zéro

Partie 7 : Le parallélisme d'instruction et les processeurs modernes 331/343
Les optimisations des accès mémoire
Dans tout ce qu'on a vu précédemment, on a surtout parlé des instructions arithmétiques et des branchements. Le chapitre sur
l’exécution Out Of Order nous a montré que l'on pouvait modifier l'ordre des instructions pour gagner en efficacité. Et avec le
chapitre sur le renommage de registre, on a vu comment supprimer certaines dépendances entre instructions lorsque ces
instructions utilisant des registres. Ainsi, si deux instructions réutilisaient le même registre, mais à des instants différents, on
pouvait supprimer les dépendances WAR et WAW qui en résultait.
Le seul problème, c'est que tout cela n'est valable que pour les instructions travaillant sur des registres. Si nos instructions
doivent aller lire ou écrire dans la mémoire, le renommage de registre ne servira à rien ! Dans ce cas précis, on ne peut donc
supprimer les dépendances WAR et WAW avec ce genre de techniques, ce qui diminue les possibilités d’exécution Out Of
Order. Pour améliorer la situation, il a fallu trouver un moyen de limiter les effets de ces dépendances de données entre
instructions d'accès mémoires. Pour ce faire, les concepteurs de processeurs et les chercheurs en architecture des ordinateurs
ont inventés diverses techniques plus ou moins efficaces permettant de gérer ces dépendances entre instructions mémoires. Ces
techniques sont ce qu'on appelle des techniques de Memory Disambiguation.
Dépendances, le retour !
Modifier l'ordre d’exécution des accès à la mémoire est une chose assez efficace en terme de performances. Par exemple, il vaut
mieux effectuer les lectures le plus tôt possible. Il faut dire que ces lectures prennent un certain temps : accéder à une donnée ne
se fait pas immédiatement. Cela peut prendre moins de 10 cycles d'horloge pour un accès au cache L1, mais peut facilement
monter et atteindre des nombres à 2 chiffres pour les accès au L2, et trois chiffres pour les accès à la mémoire. Autant dire que ne
rien faire durant cet accès au cache ou à la mémoire, et faire attendre les instructions suivant une instruction de lecture n'est pas
une bonne chose. L'idéal serait d’exécuter des instructions indépendantes de l'accès en mémoire pendant qu'on attend que la
donnée voulue soit lue. Pour ce faire, il suffit d’exécuter la lecture le plus précocement possible, et éxecuter des instructions
indépendantes pendant ce temps.
Seul problème : il faut que toutes les instructions ayant une dépendance avec cette lecture aient déjà finies de s’exécuter avant
qu'on puisse lancer la lecture. Si on se trouve dans un tel cas, il se peut que l'on ne puisse démarrer notre lecture aussi tôt que
prévu, parce qu'une instruction ayant une dépendance avec notre lecture n'est pas terminée : impossible de faire passer notre
lecture avant celle-ci. Reste à savoir si ces dépendances sont monnaie courante.
Utilité
Dans le chapitre précédent, on a vu que ces dépendances naissaient lorsque l'on des instructions différentes veulent lire ou
écrire dans des emplacements mémoire identiques. Dans les cas des registres, cela arrive très souvent : un processeur possède
souvent une faible quantité de registres, qui doit donc être utilisée au mieux. Ainsi, nos compilateurs n’hésitent pas à réutiliser
des registres dès que possible, et n'hésitent pas à écraser des données qui ne sont plus nécessaires pour stocker des résultats
utiles. Réutiliser des registres le plus possible fait donc apparaitre de nombreuses dépendances WAR et WAW. Mais pour les
accès mémoires, c'est autre chose. Accéder à la mémoire n'est pas rare, certes, mais réutiliser de la mémoire l'est. Il est en effet très
rare qu'on doive lire ou écrire à des adresses identiques dans un cours laps de temps, et rares sont les dépendances WAR et
WAW. Il faut dire que ces situations correspondent souvent à des données qui sont stockées temporairement sur la pile, à cause
d'un manque de registres. On pourrait donc croire que chercher à supprimer les dépendances WAR et WAW pour les accès à la
mémoire ne servirait que marginalement, et ne serait donc qu'un coup d'épée dans l'eau.
Mais la situation est beaucoup plus compliquée que ce que cette présentation naïve vous l'a laissé entendre.
De nouvelles dépendances
Le seul truc, c'est que notre processeur ne peut pas toujours savoir si deux accès à la mémoire vont se faire au même endroit ou
pas. Pour les instructions utilisant l'adressage absolu (l'adresse à laquelle lire ou écrire est stockée dans la suite de bits
représentant notre instruction), il n'y a pas de problèmes. Mais le seul truc, c'est que ce n'est pas le cas pour d'autres modes
d'adressages. Par exemple, il n'est pas rare que nos adresses soient stockées dans des registres. Il est en effet monnaie courante
de ne pas connaitre à l'avance les adresses à laquelle lire ou écrire, et calculer des adresses est une chose commune de nos jours.
Dans des cas pareils, il est impossible de savoir si deux accès à la mémoire se font à la même adresse ou pas.
Bilan : deux accès à la mémoire peuvent être totalement indépendants, mais le processeur ne peut pas le savoir. Résultat : il est
obligé de supposer par sécurité que ces deux accès sont dépendants, ce qui va limiter ses possibilités. Il ne pourra pas changer
l'ordre de ses instructions pour gagner en efficacité. Et cela arrive très souvent : presque à chaque accès mémoire !
Il faut noter que ce genre de situations arrive aussi dans un domaine assez éloigné. Certains compilateurs doivent faire face à un
problème similaire dans certaines situations : dans certaines conditions, ils ne savent pas si deux adresses mémoire utilisées
dans un programme sont différentes ou pas. Et dans ces conditions, ils doivent éviter de modifier l'ordre des accès à ces
adresses, ce qui limite grandement les possibilités d’optimisation. C'est ce qu'on appelle le phénomènes d'aliasing des pointeurs.
www.siteduzero.com