Discussion:
Analyse utilisation mémoire C
(trop ancien pour répondre)
tTh
2023-02-03 07:16:30 UTC
Permalink
Bonsoir à toutes et tous,
existe-t-il un outil permettant d'analyser l'espace mémoire utilisé par
les variable dans un programme en C ?
L'analyse serait réprésentée sous la forme d'un graphique ou d'un
tableau: telle variable int occupe tant d'octets, ou tel % de la taille
totale de la mémoire, tel tableau de char tant d'octets, etc.
En gros ça serait quelque chose qui automatise l'utilisation de la
fonction sizeof sur toutes les variables du programme.
Je sais pas si je m'explique bien :)
Merci par avance,
Pascal
Et pourquoi ne pas aller poser la question dans le groupe C ?
--
+-------------------------------------------------------------------+
| https://danstonchat.com/1138.html |
+-------------------------------------------------------------------+
Pascal06
2023-02-03 09:24:15 UTC
Permalink
Post by tTh
Et pourquoi ne pas aller poser la question dans le groupe C ?
Bonne suggestion effectivement, j'y ai pensé. Mais je me suis dit qu'ici
il y a pas mal de gens qui bidouillent sur des microcontrôleurs :)
J'y vais de ce pas.
Pascal06
2023-02-03 11:32:35 UTC
Permalink
Post by tTh
Et pourquoi ne pas aller poser la question dans le groupe C ?
Oh désolé, je n'avais pas vu que tu avais fait un follow up ;) merci
Donc du coup, pour préciser ma demande:
Je ne cherche pas à connaître la taille des variables dans le code
compilé, mais plutôt je cherche à faire un récapitulatif des variables
utilisées dans le code non compilé.

Par exemple:
void main (void){
unsigned char unevariable;
unsigned char unevariable2[2];

// un code
}

void unefonction (void) {

int variablefonction;

// un autre code
}

L'outil enquestion me donnerait un récapitulatif des variables sous forme
de fichier csv (par exemple):
fonction;variable;type;taille_octets;
"void main (void)";"unevariable";"unsigned char";1;
"void main (void)";"unevariable2[2];"unsigned char";2;
"void unefonction (void)";variablefonction";"int";4;

On voit dans cet exemple simpliste que les tailles en octets seraient le
résultats obtenus par sizeof();
notamment j'ai volontairement pris pour exemple le résultat de
sizeof(int) qui dépend fortement du processeur cible :)

Pascal
eps
2023-02-09 20:21:46 UTC
Permalink
Post by Pascal06
Je ne cherche pas à connaître la taille des variables dans le code
compilé, mais plutôt je cherche à faire un récapitulatif des variables
utilisées dans le code non compilé.
Par exemple: void main (void){
unsigned char unevariable;
Post by Pascal06
unsigned char unevariable2[2];
// un code
}
void unefonction (void) {
int variablefonction;
// un autre code }
L'outil enquestion me donnerait un récapitulatif des variables sous
forme de fichier csv (par exemple): fonction;variable;type;taille_octets;
"void main (void)";"unevariable";"unsigned char";1;
"void main (void)";"unevariable2[2];"unsigned char";2;
"void unefonction (void)";variablefonction";"int";4;
On voit dans cet exemple simpliste que les tailles en octets seraient le
résultats obtenus par sizeof(); notamment j'ai volontairement pris pour
exemple le résultat de sizeof(int) qui dépend fortement du processeur
cible :)
Pascal
Pour information, une variable après compilation peut très bien ne pas
utiliser de mémoire sur la pile car le compilateur peut très bien
décider d'utiliser un registre dédié ceci dépend du compilateur et des
options de compilations.

Ensuite il est fortement recommandé de structurer son programme et
d'utiliser des variables de bloc, et de ne pas déclarer toutes ces
variables au début de la fonction. Le but est de limiter la portée des
variables d'une part pour éviter de faire des bugs en utilisant une
variable dans un bout de la fonction alors que du point de vue
algorithmique cela n'avait pas de sens (non initialisé par exemple) et
d'autre part pour aider le compilateur a se rendre compte qu'il peut
optimiser le code généré.

Ensuite la mémoire utilisée n'est pas égale à la somme des sizeof des
variables déclarées dans la fonction.
Et la mémoire utilisée peut dépendre du compilateur des options de
compilation et la façon dont les variables ont étés déclarées.

Exemple de fonction dont la mémoire allouée n'est pas la même suivant le
compilateur et ses options.

void fonction1(void)
{
unsigned char toto;
unsigned int compteur;
short tata;
double time;
signed char tutu;

[du code ]
}

void fonction2(void)
{
double time;
unsigned int compteur;
short tata;
unsigned char toto;
signed char tutu;

[du code ]
}

Continuer la lecture sur narkive:
Loading...