Comment déterminer l'utilisation maximale de la pile dans un système intégré avec gcc?

juste au cas où personne ne vient avec une meilleure réponse, je vais poster ce que j'avais dans le commentaire à votre autre question, même si je n'ai aucune expérience en utilisant ces options et outils:

GCC 4.6 ajoute l'option -fstack-usage qui donne les statistiques d'utilisation de la pile sur une base Fonction-par-fonction.

Si vous combinez cette information avec un graphe d'appel produit par cflow ou un outil similaire, vous pouvez obtenir le type de pile analyse de profondeur que vous recherchez (un script pourrait probablement être écrit assez facilement pour le faire). Demandez au script de lire les informations d'utilisation de la pile et de charger une table des noms de fonction avec la pile utilisée par la fonction. Ensuite, le script parcourt le graphe cflow (qui peut être un arbre de texte facile à analyser), en additionnant l'utilisation de la pile associée à chaque ligne pour chaque branche dans le graphe d'appel.

Donc il semble que cela peut être fait avec GCC, mais vous pourriez avoir à bricoler ensemble le bon ensemble d'outils.

assez tard, mais pour quiconque regarde ceci, les réponses données impliquant la combinaison des sorties de fstack-utilisation et les outils de graphique d'appel comme cflow peuvent finir par être sauvagement incorrects pour n'importe quelle allocation dynamique, même bornée, parce qu'il n'y a aucune information sur quand cette allocation dynamique de pile se produit. Il n'est donc pas possible de savoir vers quelles fonctions vous devriez appliquer la valeur. Par exemple, si la sortie (simplifiée) fstack-usage est:

main        1024     dynamic,bounded
functionA    512     static
functionB     16     static

et un arbre d'appel très simple est:

main
    functionA
    functionB

l'approche naïve de combiner ces deux options peut conduire à choisir la fonction main -> comme chemin d'utilisation maximale de la pile, à 1536 octets. Mais, si la plus grande allocation dynamique de la pile dans main () est de pousser un grand argument comme un enregistrement à functionB() directement sur la pile dans un bloc conditionnel qui appelle functionB (j'ai déjà dit que c'était inventé), alors vraiment main - > functionB est le chemin d'utilisation maximale de la pile, à 1040 octets. En fonction de la conception du logiciel existant, et aussi pour d'autres cibles plus restreintes qui passent tout sur la pile, les erreurs cumulatives peuvent rapidement vous conduire à regarder des chemins entièrement erronés réclamant des tailles de pile maximales considérablement surévaluées.

en outre, selon votre classification de" rentrant " en parlant d'interruptions, il est possible de manquer certaines allocations de pile entièrement. Par exemple, de nombreux processeurs Coldfire de niveau 7 interrompent sensible aux bords et donc ignore le masque de désactivation d'interruption, donc si un sémaphore est utilisé pour laisser l'instruction en avance, vous ne pouvez pas le considérer comme rentrant, mais l'allocation initiale de la pile se produira encore avant que le sémaphore ne soit vérifié.

En bref, vous devez être extrêmement prudent sur l'utilisation de cette approche.

Je ne suis pas familier avec les options -fstack-usage et -fcallgraph-info . Cependant, il est toujours possible de calculer l'utilisation réelle de la pile par:

1. attribuer suffisamment d'espace de pile (pour cette expérience), et l'initialiser à quelque chose facilement identifiable. J'aime 0xee .
2. exécute l'application et teste tous ses chemins internes (par toutes les combinaisons d'entrée et de paramètres). Laissez-le fonctionner plus que "assez longtemps".
3. examiner la zone de la cheminée et voir quelle quantité de la cheminée a été utilisée.
4. font que la taille de la pile, plus 10% ou 20% pour tolérer les mises à jour du logiciel et des conditions rares.

j'ai fini par écrire un script python pour implémenter la réponse de τεκ . Il est trop de code à poster ici, mais peut être trouvé sur github