Comment faire pour déterminer le maximum de l'utilisation des piles?

Vous tagged votre question avec d'analyse statique, mais c'est un problème qui est difficile à résoudre par le biais d'analyse statique. L'utilisation des piles dépend du programme du profil d'exécution, en particulier, si vous êtes en utilisant la récursivité ou alloca. Étant donné que c'est une plate-forme intégrée, je suppose que c'est aussi difficile à exécuter quelque chose comme ps ou haut et de voir combien la pile de votre application utilise.

Une approche intéressante consiste à utiliser l'adresse de l'actuel cadre de la pile afin de déterminer combien de pile est utilisé. Vous pouvez le faire en prenant l'adresse d'une fonction est un argument ou d'une variable locale. Que faire pour les principal fonction et pour les fonctions que vous pensez sont à l'aide de la plupart de la pile. La différence va vous dire le montant de la pile de votre application. Voici un exemple (en supposant coutumier de faible à élevée, croissance de la pile).

char *stack_top, stack_bottom;

int
main(int argc, char *argv[])
{
    stack_top = (char *)&argc;
    //...
    printf("Stack usage: %d\n", stack_top - stack_bottom);
}

void
deeply_nested_function(void)
{
    int a;
    stack_bottom = (char *)&a;
    //...
}

Si votre compilateur permet de spécifier une fonction personnalisée prologue (beaucoup de le faire pour permettre à base de graphe programme de profilage), vous pouvez même organiser pour toutes les fonctions à appeler un tel code de mesurage. Ensuite, votre fonction de mesure mecomes quelque chose comme

void
stack_measurement_function(void)
{
    int a;
    stack_bottom = min(stack_bottom, (char *)&a);
    //...
}

J'ai utilisé une approche similaire à ce que j'ai décrit pour générer ces cartes.

Je suis en train de travailler sur ce problème dès maintenant - c'est à dire le calcul analytique de stacksize.
Il est de toute évidence un très récursive morceau de code, en raison d'un appel de fonction pourrait avoir un tableau indexé, ou un ou plusieurs de ses arguments et un ou plusieurs des indices de tableau pourrait impliquer des appels de fonction!!

Cependant, un couple de réalisations permettent un certain soulagement de la complexité:

(1) Lors de l'utilisation d'un langage de haut niveau du compilateur, le stackpointer à la fin de l'exécution de chaque instruction/la ligne de code doit être à la même place, comme il l'était au début.
(Au moins, ce serait une bonne règle à respecter, sinon vous allez avoir des problèmes!)

(2)Le stackpointer après le retour de chaque fonction ou une sous-routine d'appel doit être la même qu'elle était avant l'appel. Par conséquent, le maximum de la taille de la pile est le maximum, plus que toutes les instructions du programme, de la pointe stacksize atteint dans chaque état.
(Au moins, ce serait une bonne règle à respecter, sinon vous allez avoir des problèmes!)

De cours d'une instruction peut inclure le récursive problèmes que j'ai mentionnés ci-dessus, mais au moins le problème de trouver le maximum d'stacksize exigence de tout un programme, puis revient à trouver le maximum d'stacksize exigence de chaque énoncé, puis ramasser le maximum de personnes.

Ce ne peut être complété jusqu'à ce que toutes les fonctions appelées ont été compilés. J'ai donc générer un fichier pour chaque module compilé qui enregistre un certain nombre de stacksizes pour chaque énoncé
(en gros la valeur de crête avant chaque appel de la fonction et de la valeur immmediately avant chaque appel de fonction (à l'exclusion de toute encore inconnu des ajouts à stacksize causés par l'appel de la fonction), et les noms de fonction en cause. Ensuite, j'ai rétrospectivement traiter ces fichiers à l'aide d'une routine récursive, une fois que toutes les fonctions ont été compilés, pour déterminer les pics stacksize.

La chance, c'est que, fonctions récursives outre, le maximum possible stacksize exigence ne dépend alors de flux de programme, bien que dans un flux typique (qui sont des données dépendantes) ce maximum possible stacksize ne peut jamais être atteint.

Exemple: Supposons que la fonction 1 les appels de fonction 2 et le déroulement du programme, à la fois dépend de la valeur de données de X. Supposons qu'il y est une gamme de X qui provoque de fonction 1 à l'exécution de ses pires déclaration, qui comprend un appel à la fonction 2, qui n'exécute pas son pire des cas, la déclaration pour la même gamme de X. Puisque nous avons calculé le maximum possible stacksize en utilisant le pire des cas pour les deux fonction 1 et la fonction 2 en même temps, nous pouvons avoir surestimé la taille de la pile. Au moins nous avons commis une erreur sur le côté sécuritaire.

J'aime faire des routines d'interruption de leur propre stackspace sur un OS de la pile si elle a besoin, afin de ne pas ajouter à la pile de programme exigences, à part le retour de l'interruption de l'adresse