C ++ volatile

«Les développeurs d'applications d'espace utilisateur devraient toujours référencer les manuels du compilateur pertinent pour savoir comment le qualificatif peut être géré dans divers contextes car le comportement des mots clés volatile doit normalement être considéré comme dépendant du matériel. Lorsqu'un objet est marqué comme volatile, le compilateur est souvent informé qu'il ne doit jamais être optimisé pour les opérations de charge et doit toujours être récupéré de la mémoire primaire plutôt que des registres ou des caches. Cependant, lorsque le compilateur essaie de mettre l'emplacement de la mémoire dans le registre, il est automatiquement mis en cache même s'il existe de nombreux niveaux de caches qui ne sont pas largement indisponibles pour les logiciels et ne sont maintenus que dans le matériel. En conséquence, la RAM est accessible plusieurs fois plus rapidement à partir de lignes de cache près du CPU que de l'emplacement de mémoire identique.

Les problèmes pourraient se produire si nous n'utilisons pas un qualificatif volatil qui comprend, lorsque l'optimisation est activée, le code peut ne pas fonctionner comme prévu. Lorsque les interruptions sont utilisées et activées, le code ne peut pas fonctionner comme prévu. Les données ne sont conservées que dans un stockage volatil pendant que l'alimentation est activée. Lorsque l'alimentation est supprimée, la perte de données se produit.

Cependant, le stockage non volatile conserve des données même si l'alimentation s'éteint. Les informations du processus sont brièvement stockées sur un stockage volatil car elles sont considérablement plus rapides que le stockage non volatile. Contrairement au stockage non volatile, le stockage volatil est plus adapté pour protéger les données sensibles. En effet, les données sont inaccessibles lorsque l'alimentation est désactivée. Le stockage volatil coûte beaucoup car les systèmes informatiques ne peuvent accueillir que quelques Mo à quelques Go."

Propriétés du qualificatif volatil en C++

Le moyen de qualification volatile C ++ sera démontré ici. Lorsque nous déclarons une variable, la qualification «volatile» est appliquée. Il rappelle au compilateur que la valeur est susceptible de varier à tout moment. Les volatils possèdent certains des traits énumérés ci-dessous.

• L'attribution de la mémoire ne peut pas être modifiée avec le mot clé volatil.

• Les variables du registre ne peuvent pas être mises en cache.

• En termes de cession, la valeur ne peut pas être modifiée.

Utilisation de la qualification volatile en C++

1. Bien que votre code ne modifie pas la valeur de la variable, il pourrait néanmoins le faire. En conséquence, chaque fois que le compilateur vérifie l'état de la variable, il ne peut pas supposer qu'il est le même que la valeur la plus récente en cours ou la valeur la plus récente stockée; il doit plutôt acquérir une fois de plus la valeur de la variable.

2. Le compilateur n'est pas tenu d'éliminer l'acte de stockage d'une valeur car il s'agit d'un «effet secondaire» qui peut être vu de l'extérieur et se produit lorsqu'une valeur est enregistrée dans une variable volatile. Par exemple, si deux valeurs sont placées dans une ligne, le compilateur doit mettre la valeur deux fois.

Syntaxe du qualificatif volatil en C++

# Volatile data_type variable_name

Le mot-clé volatil doit être utilisé dans la déclaration et le type de données fait référence à tout type de données, y compris le double, le flotteur ou. Enfin, nous choisissons un nom pour la variable. Nous pouvons définir une variable volatile en utilisant l'une des méthodes car les deux déclarations sont valides.

Exemple: le qualificatif volatil est utilisé pour identifier les objets qui peuvent être modifiés par d'autres threads ou des actions extérieures en C++

Si l'objet est modifié par un signal extérieur ou une procédure qui agit comme une interruption, la valeur modifiée doit être récupérée de la RAM parce que l'état mis en cache n'est plus approprié entre-temps. En conséquence, le compilateur gère l'accès aux objets volatils de manière appropriée.

#inclure
#inclure
#inclure
Utilisation de std :: cout;
Utilisation de std :: endl;
Utilisation de Std :: Cerr;
Utilisation de STD :: CIN;
INT VOLATILE SECONDES = 0;
vide delayfivesEcondes ()
pendant que (secondes < 3)
Usleep (200000);
cerr<< "waiting… " <

vide incrementiques ()
pour (int i = 0; i< 5; ++i)
sommeil (1);
cerr<< "incremented " <secondes = secondes + 1;


int main()
struct timeVal start ;
struct timeVal end ;
std :: thread thread1;
thread1 = std :: thread (incrémentsCondels);
DelayFivesEcondes ();
thread1.rejoindre();
return exit_success;

Pour illustrer le scénario potentiel, nous avons utilisé le mot clé volatil qui a la variable déclarée comme des secondes de type de données «int» et attribué une valeur de 0. Ensuite, nous construisons deux fonctions: l'une comme «DelayFivesEcondes» qui modifie la variable entière volatile globale, et une autre en tant que «incréments» qui effectue la même évaluation à l'intérieur de la boucle while. Il convient de noter que cet exemple permet à la boucle de boucle de faire boucler sur les secondes lorsque les secondes doivent être inférieures à 3.

Lorsque la condition se réunira, le bloc While sera exécuté. À l'intérieur du bloc While, nous avons invoqué la méthode non endormie qui imprime la déclaration «en attente». La fonction «incréments» a la boucle pour. Après l'itération, la méthode de sommeil est invoquée, qui imprime l'instruction «incrément» et incréments la variable «secondes». L'exécution initiale de la fonction «incréments» est effectuée par un thread séparé créé par la fonction principale. La méthode «DelayFivesEcondes» est ensuite appelée par le thread principal, entrant dans une boucle qui ne se terminera pas si la variable de secondes ne dépasse pas la valeur de 5.

Dès que le thread principal remarque la valeur de la variable des secondes a changé, il reviendra de la méthode car un autre thread a déjà commencé à augmenter simultanément.

Pour exécuter le code de thread en C ++, nous devons utiliser la commande «g ++ -pthread -o nom de fichier de fichier.CC ". Si vous ne déploiez pas le «-pthread» dans la commande, il y a une chance qu'une exception soit lancée par le compilateur. En conséquence, nous avons effectivement fait une fonction d'attente conditionnelle qui attend que l'objet volatile soit modifié par une force extérieure. Il est important de garder à l'esprit que le bloc de code de mise à jour pourrait provenir d'une section de traduction différente ou d'une action de signal externe, même si ce code fonctionnera toujours de la même manière si le qualificatif volatil est supprimé et qu'une variable globale conventionnelle est utilisée.

Conclusion

Ici, nous passons en revue un aperçu de la volatile en C ++ avec la syntaxe, l'utilisation et les exemples appropriés pour une meilleure compréhension. Étant donné que le compilateur ne peut pas prédire la valeur, le volatile est crucial dans la programmation C. Le principal avantage de l'utilisation du volatile est que sa valeur peut varier chaque fois qu'un utilisateur le demande à modifier ou quand un autre thread utilisant la même variable est actif.