Volatile – que verrai-je dans le débogueur ?

Bonjour !

J’ai appris comment fonctionne volatile parce que j’utilise des microcontrôleurs. J’ai en partie besoin de savoir comment cela fonctionne. J’ai appris comment fonctionnent les sites Web en matière de code pseudo assembleur. J’ajouterai ces informations pour montrer ce que je sais et ce que j’avais envie de grignoter.

Tellement volatile arrête le compilateur pour optimiser une variable qui, selon lui, ne sera pas mise à jour dans un gros résumé ou d’autres processus ne seront pas optimisés par le compilateur.

Quelque chose comme ça :

Non volatile :

move the value of variable m into internal register A
label:
if A != 1 goto done
goto label
done:
carry on

Donc la variable m est lu une fois et il ne lira jamais la valeur m encore une fois, même si le m peut changer sa valeur. Il pense que cela ne changera jamais

Volatil :

label:<br />
move the value of variable 'm' to internal register A<br />
if A != 1 then go to done<br />
go to label<br />
done:

Ici, avec volatile, il lira à chaque fois quelle variable m a à l’intérieur.

A quoi ça ressemble avec ISR (interrupt route) ?
C’est un exemple que j’ai également lu sur des sites Web et qui m’explique beaucoup comment cela fonctionne.

Citation:

* dans la boucle principale – juste avant l’exécution d’ISR – il a la valeur “X” dans le registre 1
* ISR démarre, ISR enregistre la valeur du registre 1 (X) dans la SRAM (pile ?)
* ISR utilise le registre 1 avec ses propres valeurs, charge avec abc, modifie def… n’importe quoi, effectue des opérations
* avant de revenir à main(), il restaure la valeur “X” dans le registre 1.

La valeur des variables est enregistrée dans la mémoire/RAM, etc. dans laquelle les opérations sont stockées dans des registres. Cela m’a fait comprendre très clairement qu’ISR ne met à jour que la valeur de la variable en mémoire et non dans le registre, car les registres reviennent à leur état précédent avant la modification.

Cool

Maintenant, ce que je voulais savoir, c’est maintenant comment fonctionne volatile, etc. parce que je sais en partie comment cela fonctionne. Je veux savoir comment je vais le voir dans le débogueur.

Utilisons cet exemple :

int A = 0;

int main()
{
	while(A != 1)
	{
	//Do something
	}
}

void ISR()

{
	A++;
}

Voici un code simple sans volatile. Je voulais savoir comment le débogueur se comporterait.

int A = 0;

int main()
{
	while(A != 1)
	{
	//Do something
	}
}

void ISR()

{
	A++; <----- breakpoint
}

J’ai défini un point d’arrêt ici.
La variable A est mise à jour de 0 à 1. Mais la boucle while ne lira pas la variable A, elle est plutôt optimisée et lira la valeur 0 de son registre comme je l’ai dit au début.

D’accord, la variable A a été mise à jour de 0 à 1 et le débogueur affichera la valeur de A comme étant 1 et non 0.

int A = 0;

int main()
{
	while(A != 1) <----- breakpoint
	{
	//Do something
	}
}

void ISR()

{
	A++;
}

Ainsi, après ISR, le débogueur passe maintenant au principal et s’arrête à while car c’est mon prochain point d’arrêt.

Quelle sera la valeur de A ? Est-ce que ce sera toujours “1” comme je l’ai dit au début, comment ça marche ? A devrait toujours être 1 et le while devrait me laisser passer car même si A = 1 et la boucle while dit A != 1, elle devrait quand même passer car while lit les données du registre et non de la variable A car elle n’est pas volatile.

Pourquoi ai-je besoin de ces connaissances ? Pour l’avenir, si j’oublie et que quelque chose de bizarre se produit, cela m’aidera à savoir si j’ai oublié quelque chose comme. Pourquoi la boucle while a démarré même si la condition ne correspondait pas.

Je crois que vous comprenez ce que j’essaie de dire ici.

Ce que j’ai essayé :

Je ne savais pas à quoi ça ressemblerait car mon microcontrôleur n’optimisait pas les variables non volatiles comme si elles étaient volatiles donc je cherche plutôt la connaissance sans la voir normalement ;D