Où utiliser volatile?

J’ai lu des mots-clés volatiles, mais je ne sais pas dans quelles situations je devrais les utiliser.

Lorsque la mémoire (variable) est mise à jour et que le processus n’en est pas conscient?

Dans quels cas les conducteurs doivent-ils utiliser des variables volatiles?

Le cas le plus courant dans mon monde concerne la programmation de microcontrôleurs utilisant des E / S mappées en mémoire. La valeur dans un registre peut changer en raison d’entrées numériques externes, mais si vous ne déclarez pas une variable comme étant volatile , le compilateur peut optimiser le code complètement et vous vous demanderez pourquoi rien ne fonctionne.

Matt a suggéré que j’embellisse la déclaration concernant le fait que le code soit “optimisé”. Les E / S mappées en mémoire sont accessibles en code via des pointeurs. Lorsque vous souhaitez vérifier l’état d’un bouton, vous utiliserez généralement AND au niveau du bit ET la valeur du registre avec le masque binary du bouton. Si vous ne spécifiez pas volatile, le compilateur dira “hé, votre code ne change jamais réellement la valeur de ce pointeur. Je vais donc simplement supprimer cette instruction à partir de laquelle vous l’avez ANDée au niveau du bit, car la valeur est toujours le même!”.

Espérons que cela efface un peu ma déclaration. Merci pour la suggestion, Matt.

Comme vous l’avez marqué avec la balise linux-device-driver , des conseils spécifiques pour le codage dans le kernel Linux sont probablement utiles.

En général, vous ne devriez pas avoir besoin d’écrire volatile dans le code de votre kernel Linux. Dans les cas où la volatile pourrait être requirejse, son utilisation est encapsulée dans les fonctions principales du kernel que vous devriez appeler à la place. Par exemple, si vous effectuez des E / S mappées en mémoire, vous devriez utiliser ioremap() , writel() , readl() etc.

En dehors de ce que d’autres ont dit, le mot-clé volatile est généralement destiné à empêcher la forme du compilateur de procéder à l’optimisation. Dans certains registres mappés en mémoire où la valeur des registres est conservée comme si un mot clé volatile était utilisé. Jetez un oeil à cet exemple:

 RTC_CLOCK _time; TIME _currentTime = _time ; while(_currentTime - _time >= 100) { //Do something } //rest of the code 

Si nous n’ajoutons pas le mot clé volatile avant TIME, ce code sera comme ceci: _currentTime – _time = 0 et le compilateur ne considérera pas la boucle while en dessous:

 RTC_CLOCK _time; TIME _currentTime = _time ; //rest of the code 

pour éviter cela, nous devons utiliser le mot clé volatile avec TIME.

Cela pourrait vous être utile

http://www.kcomputing.com/volatile.html

Les variables volatiles sont des variables qui peuvent être modifiées à tout moment, sans que le programme ne le sache.

Je ne vois aucune utilité au mot-clé volatile dans la programmation quotidienne, mais il pourrait bien surgir.

A ma connaissance, en C, le mot-clé volatile devrait être utilisé lorsque des opérations non synchronisées simultanées sont effectuées sur une variable provenant de plusieurs sources (processus). Si la variable est déclarée volatile , tous les processus accéderont toujours directement à la variable depuis son emplacement de mémoire, par opposition à la copie de la variable dans le cache du microprocesseur et à son access à partir de cet emplacement.
Notez que cela réduira considérablement les performances pour cette variable particulière. Le temps d’access pour les variables en mémoire est de l’ordre de la milliseconde, tandis que pour les variables de cache de niveau 1 ou 2, il se situe autour de dixièmes de nanosecondes. Utilisez-les uniquement lorsque toutes les autres options ont été sockets en compte.