Comportement volatile et en cache

Je lis post
C variables volatiles et mémoire cache

Mais je suis confus.

Question:
si OS prendra soin d’elle-même OU
le programmeur doit écrire le programme de telle manière que la variable ne soit pas mise en cache comme le mentionne la déclaration de variable comme _Uncached.

Cordialement
Apprenant

Clarifier:

volatile est un concept C et demande au compilateur d’extraire une variable de la mémoire à chaque fois plutôt que d’utiliser une version en cache “générée par le compilateur” dans des registres ou d’optimiser certains codes.

Ce qui peut causer de la confusion ici, ce sont les caches de processeur contre les caches de logiciels (ou variables dans les registres).

Le cache CPU / Matériel est transparent à 100% pour le programme et le matériel s’assure qu’il est synchronisé à 100%. Il n’y a pas de quoi s’inquiéter ici. Lorsque vous lancez une load partir de la mémoire et que les données proviennent du cache de la CPU, il s’agit des mêmes données que dans la mémoire adressée.

Votre compilateur peut décider de “mettre en cache” les variables d’utilisation fréquente dans des registres qui risquent de ne plus être synchronisés avec la mémoire car le matériel n’en a pas conscience. C’est ce que le mot clé volatile empêche. Exemple commun:

 int * lock; while (*lock) { // do work // lock mot modified or accessed here } 

Un compilateur optimiseur verra que vous n’utilisez pas lock dans la boucle et le convertira en:

 if (*lock) while (true) { // do work } 

Ce n’est évidemment pas le comportement souhaité si le lock doit être modifié, par exemple, par un autre thread. SO vous le marquez volatil pour empêcher ceci:

 volatile int * lock; while (*lock) { // do work } 

J’espère que cela le rend un peu plus clair.

J’ai lu cette page wiki volatile , elle donne un exemple sur la manière dont gcc optimise les variables non volatiles et sur la manière dont ‘volatile’ empêche l’optimisation de gcc.
J’ai remarqué qu’après avoir utilisé ‘volatile’ pour qualifier les variables, gcc n’optimisait certes pas les variables ‘volatiles’, mais qu’à chaque lecture / écriture, les instructions générées utilisaient ‘movl’ pour accéder. Je veux dire, lorsque l’instruction ‘movl’ émet une adresse de données, comment le kernel, le processeur ou d’autres éléments déterminent-ils s’il doit le lire dans le cache ou dans la mémoire?
Sergey L. a mentionné les points clés suivants:

Votre compilateur peut décider de “mettre en cache” les variables d’utilisation fréquente dans des registres qui risquent de ne plus être synchronisés avec la mémoire car le matériel n’en a pas conscience. C’est ce que le mot clé volatile empêche.

Comme l’a mentionné Sergey L. , je comprends maintenant que «volatile» n’empêche que l’optimisation du compilateur concerne le «cache logiciel» , c’est-à-dire que l’utilisation fréquente de variables dans les registres plutôt que le cache cpu, et que «volatile» ne peut pas garantir la visibilité entre différents threads?
Je suis toujours très confus, peut-être que je ne comprends toujours pas cela.