Mesure de l'utilisation de la pile pour l'application multi-thread Linux

Question

Je développe une application multi-thread pour une plate-forme embarquée Linux.

Pour l'instant, je définis la taille de la pile pour chaque thread (via pthread_set_attr) à une valeur par défaut assez importante. Je voudrais affiner cette valeur pour chaque thread à quelque chose de plus petit pour réduire l'utilisation de la mémoire de mon application. Je pourrais passer par la route d'essai et d'erreur de la taille de la pile de chaque thread à des valeurs progressivement plus petites jusqu'à ce que le programme plante, mais l'application utilise ~ 15 threads avec des fonctionnalités/attributs complètement différents, ce qui prendrait beaucoup de temps.

Je préférerais de loin pouvoir mesurer directement l'utilisation de la pile de chaque fil. Y a-t-il des utilités que les gens peuvent recommander? (Par exemple, je viens d'un milieu VxWorks et en utilisant la commande « ti » des vxWorks shell donne directement des statistiques sur l'utilisation de la pile, ainsi que d'autres informations utiles sur l'état de la tâche.)

Merci

Answer 1

I ne savent pas de bons outils, mais en dernier recours, vous pouvez inclure un code dans votre application pour vérifier, semblable à ce qui suit:

__thread void* stack_start; 
__thread long stack_max_size = 0L; 

void check_stack_size() { 
    // address of 'nowhere' approximates end of stack 
    char nowhere; 
    void* stack_end = (void*)&nowhere; 
    // may want to double check stack grows downward on your platform 
    long stack_size = (long)stack_start - (long)stack_end; 
    // update max_stack_size for this thread 
    if (stack_size > stack_max_size) 
    stack_max_size = stack_size; 
} 

la fonction check_stack_size() devrait être appelé dans certaines des fonctions sont les plus profondément imbriqués.

Ensuite, en tant que dernière instruction du thread, vous pouvez renvoyer stack_max_size à quelque part.

La variable stack_start devrait être initialisé au début de votre fil:

void thread_proc() { 
    char nowhere; 
    stack_start = (void*)&nowhere; 
    // do stuff including calls to check_stack_size() 
    // in deeply nested functions 
    // output stack_max_size here 
} 

Answer 2

Référencer réponse de Tobi: Vous pouvez utiliser pthread_attr_getstackaddr pour obtenir la base de la pile à tout moment, si le réglage d'une variable au fil l'initialisation est difficile. Vous pouvez ensuite obtenir l'adresse d'une variable automatique dans votre propre fonction pour déterminer la profondeur de la pile à ce moment.

Answer 3

Voici deux outils qui mesurent (pthreads natifs) de l'utilisation de la pile dans les applications Linux:

• Valgrind
• Stackusage

Valgrind

Utilisation:

valgrind --tool=drd --show-stack-usage=yes PROG 

Valgrind est un outil stable et puissant, utile non seulement pour mesurer l'utilisation de la pile. Cependant, il se peut qu'il ne supporte pas tous les modèles de processeurs embarqués.

Stackusage

Utilisation:

stackusage PROG 

Stackusage est un outil léger spécialement conçu pour la mesure de l'utilisation de la pile de fil qui doit être portable pour Linux embarqués plus équipés de glibc. Il n'est probablement pas aussi bien testé ou mature que Valgrind/drd à ce stade.Full description: Je suis l'auteur de Stackusage.