Variables globales et mémoire - Page 1

Bonjour à tous !

M'étant relancé dans un projet nécessitant l'appel à de nombreuses fonctions et ne souhaitant pas mettre dans le prototype de chaque fonction les 6 ou 7 noms de variables dont elles ont besoin, j'ai décidé de mettre les variables les plus couramment utilisées en tant que variables globales.

Je pensais alors que ces variables seraient seulement accessibles depuis toute autre fonction du programme.

Cependant j'ignorais qu'elles étaient aussi conservées après avoir quitté le programme et qu'elles gardaient leur valeur lorsqu'on relance le programme.

J'ai donc plusieurs questions :
-Après avoir lancé pour la première fois mon programme je me suis rendu compte que je perdais un peu de RAM (logique ^^). Cependant le poids de mon programme en tant que tel ne bouge pas. Où sont stockées dans la mémoire les variables globales ?

-Comment faire pour ne pas conserver les variables globales après la fin de mon programme ?

Merci d'avance de vos réponses !

Tes variable sont indiquée comem statiques ?

Justement non, ce n'est ni une fuite de mémoire ni l'entrée dans l'écran Home (j'ai bien tout vérifié ^^).
De plus cette perte de mémoire ne se produit que la première fois que je lance le programme (ce qui est plutôt logique, si on considère que c'est à ce moment que sont stockées pour la première fois les variables globales en mémoire).

Je les initialise bien sur au lancement mais cela n'y fait rien : elles ne sont initialisées que la première fois que je lance le programme, ensuite elles gardent la dernière valeur qui leur a été attribuée avant la fin du programme.

Godzil : Nan je les ai juste sorties de la boucle _main.

[EDIT] : un 'a' à la place d'un 'e'.

> -Comment faire pour ne pas conserver les variables globales après la fin de mon programme ?
Les réinitialiser au début de ton programme
(tu peux aussi utiliser un programme compressé)

De plus cette perte de mémoire ne se produit que la première fois que je lance le programme (ce qui est plutôt logique, si on considère que c'est à ce moment que sont stockées pour la première fois les variables globales en mémoire).

Ben, non, ce n'est pas logique pour un programme ASM: car les variables globales sont soit déjà stockées dans l'image mémoire de ton programme, soit ce sont des BSS alloués avant _main et désalloués après _main.

Tu veux dire dans le _main Lionel ? C'est une bonne idée mais ne serait-il pas possible de purement et simplement les supprimer quand je quitte le programme ?

[CROSS] : Bon je vais refaire l'expérience dans ce cas (l'erreur est humaine, je me suis peut-être gouré).

[EDIT] : Faudrait que j'utilise plus souvent les citations moi... ça devient difficile à suivre comme sujet avec les cross etc..

Voici le protocole de l'expérience que je viens de refaire :
1-Démarrage de TiEmu avec la calculatrice choisie (dans mon cas successivement TI89 Titanium et Voyage 200)
2-J'envoie mon programme sur la calculatrice, sans le lancer.
3-Observation de la RAM libre (respectivement 189296 et 186882 octets) avec aucune entrée dans l'historique de l'écran Home.
4-Lancement du programme, et test des diverses fonctions disponibles.
5-Retour à l'écran Home, et effacement de l'entrée créée dans l'historique, ainsi que de l'appel du programme.
6-Nouvelle observation de la RAM libre : 189286 et 186872 octets.

J'ai ensuite renouvelé l'expérience à partir de l'étape 4 et là je ne perdais plus de RAM : je n'ai donc pas affaire à une fuite de mémoire.

Cependant c'est vrai qu'il est étonnant que je perde 10 octets au premier lancement, surtout étant donné que la somme de poids de mes variables globales dépasse les 10 octets.

ne serait-il pas possible de purement et simplement les supprimer quand je quitte le programme ?

Non

Les 10 octets pourraient plus probablement être un redimensionnement de la Home Screen Line. Quel est l'effet sur la mémoire consommée si tu fais
1-Démarrage de TiEmu avec la calculatrice choisie (dans mon cas successivement TI89 Titanium et Voyage 200)
2-J'envoie mon programme sur la calculatrice, sans le lancer.
3-Observation de la RAM libre (? octets) avec aucune entrée dans l'historique de l'écran Home.
4-Exécution de la ligne 12345678901234567890123456789012345678901234567890
5-Effacement de l'entrée créée dans l'historique, ainsi que de l'appel du programme.
6-Nouvelle observation de la RAM libre : ? octets.

Folco> J'ai en effet perdu 8 octets en faisant juste un HeapCompress ! De la même façon cela ne le fait qu'une seule fois : la première fois que je lance le programme.

Lionel> Avec ton protocole, je suis passé de 189296 à 189244 ! Il y a donc bien eu un redimensionnement de la barre de saisie de l'écran Home.

Merci beaucoup, je pense qu'on tient les deux causes (8 octets dus à la compression et 2 octets dus au redimensionnement).
Cependant pourquoi est-ce que je perds de la mémoire en compressant les blocs de mémoire (si j'ai bien comprit ce que faisait la fonction HeapCompress) ?
Pareil, puis-je récupérer (hors Reset) les octets utilisés lors du redimensionnement ?

Merci quoiqu'il en soit !

D'accord. C'est vrai qu'après tout 10 malheureux octets on s'en fiche.

Bon ben Lionel et Martial faites moi penser à vous payer une mousse si jamais vous passez à Rennes.

Merci beaucoup !

Tu n'es pas déjà sur Rennes Martial ?

bon, vu que t'as la réponse on peut dévier légèrement.

En général on aime pas trop avoir des variables globales. Ce que tu peux faire, c'est déclarer une structure, tout mettre dedans, et passer juste le pointeur de cette structure dans tes fonctions.

struct machin {
	int a;
	int b;
	unsigned short c;
};

void foo(struct machin *données)
{
	données->a=42;
	données->b=53;
	données->c=0x55AA;
}

void bar(struct machin *données)
{
	printf("a=%d b=%d c=%04x",données->a, donnees->b, donnees->c);
}

int _main(void)
{
	struct machin stockage;
	foo(&stockage);
	bar(&stockage);
}

//tout est libéré car c'était dans la pile

//tu peux aussi faire avec la heap
int _main(void)
{
	struct machin *stock;
	stock=(struct machin*)malloc(sizeof(struct machin));
	foo(stockage);
	bar(stockage);
	free(stockage);
}

C'est une autre possibilité, mais elle ne donne pas forcément du meilleur code
Ca dépend des traitements effectués avec les données, du nombre de fonctions qui utilisent les données, et aussi des options de compilation, en particulier la présence ou l'absence de a) les BSS et b) les options mutuellement exclusives -mpcrel et -freg-relative-an.

c'est juste une compression de place pour des variables initialisées à zéro

Squalyl> J'avais pensé aussi à créer une structure, mais n'en utilisant jamais j'ai préféré rester aux variables globales. En plus je me suis rendu compte que finalement la propriété qui fait que les valeurs de mes variables globales se conservent entre deux lancements du programme peut m'être très utile.

Sinon j'ai découvert il y a peu un truc que je n'utilisais jamais avant et dont je n'avais pas entendu parler, alors que c'est plutôt pratique pour gagner de la place quand on code : l'opérateur ternaire (j'ai trouvé sous ce nom là pour le '?', je ne sais pas si c'est vraiment ça).

Voila ce que ça donne :

resultat=((condition1)? valeurVraie : valeurFausse);

équivaut grosso modo à :

if (condition1)
resultat=valeurVraie;
else
resultat= valeurFausse;

Sauf qu'on plus on peut l'utiliser dans un appel de fonction !

C'est super pratique (même si c'est un peu illisible, surtout quand il y a plusieurs test imbriqués).

Est-ce qu'il y a des inconvénients à utiliser ces instructions?

Moins lisible dans certains cas, et si tu veux mettre des instructions dans tes 2 branches, il faut utiliser l'extension GNU ({...}), ce n'est pas possible en C standard. Mais quand c'est possible et quand le code dans le ?: n'est pas trop compliqué, le ?: est très pratique.

Merci de la précision.

J'apporte une petite précision sur la conservation des variables globales : Ce n'est valable que lorsque le programme est en RAM. Un programme archivé ne conserve pas les valeurs des variables globales.

(Sous UniOS il me semble que JM avait choisi de recopier le programme même s'il était en RAM.)

Effectivement. Et de toute façon un programme qui ne fonctionne pas (ou pas entièrement) quand il est archivé sux. Il faut obligatoirement utiliser un fichier externe pour sauvegarder ses données.

Thibaut (./24) :
J'apporte une petite précision sur la conservation des variables globales : Ce n'est valable que lorsque le programme est en RAM. Un programme archivé ne conserve pas les valeurs des variables globales.

Et un programme compressé non plus

En effet, cette précision m'intéresse puisque je pensais utiliser cette propriété des variables globales.
Enfin si je ne peux pas le faire de cette façon, je trouverais un autre moyen de le faire voila tout.

J'en profite pour dire que ça avance bien : bientôt les premiers screenshots du programme.