2010-10-20 19 views
2

de source ayant comme ceci:Débogage fonctions lentes dans les programmes C (construits par gcc)

void foo() { 
    func1(); 
    if(qqq) { 
     func2(); 
    }; 
    func3(); 
    func4(); 
    for(...) { 
     func5(); 
    } 
} 

Je veux obtenir les informations comme ceci:

   void foo() { 
5 ms; 2 times; func1(); 
0 ms; 2 times; if(qqq) { 
0 ms; 0 times;  func2(); 
0 ms; 2 times; }; 
20 ms; 2 times; func3(); 
5 s ; 2 times; func4(); 
0 ms; 60 times; for(...) { 
30 ms; 60 times;  func5(); 
0 ms; 60 times; } 
       } 

à savoir des informations sur le temps moyen qu'il a fallu pour exécuter cette ligne (temps réel de l'horloge, y compris l'attente dans les syscalls) et combien de fois est-il exécuté.

Quels outils devrais-je utiliser? Je souhaite que l'outil instrumentation chaque fonction pour mesurer son temps d'exécution, qui est utilisé par l'instrumentation à l'intérieur de la fonction d'appel qui écrit le fichier journal (ou compte en mémoire, puis dumps).

+0

Pouvez-vous envisager une attente légèrement différente? Quand une ligne de code est active, elle est sur la pile, donc si vous connaissez le temps total, et la fraction de temps qu'une ligne est sur la pile, vous savez combien de temps elle est responsable. Vous pouvez obtenir cette information à partir des échantillons de la pile, et cela indique quelles lignes de code (et les fonctions, si vous préférez) apporteraient le plus d'avantages si elles étaient optimisées. –

Répondre

0

Prenez un essai de Zoom. Vous ne serez pas déçu.

P.S. Ne vous attendez pas à ce que l'instrumentation fasse l'affaire. Pour les informations au niveau de la ligne ou de la fonction, un échantillonneur de pile au moment de la livraison fournit les marchandises, en supposant que vous n'avez pas absolument besoin d'un nombre d'invocation précis (qui n'a que peu de pertinence pour les performances).


AJOUTÉE: Je suis sous Windows, donc je juste couru votre code avec LTProf. La sortie ressemble à ceci:

void foo(){ 
5 func1(); 
    if(qqq){ 
5 func2(); 
    } 
5 func3(); 
5 func4(); 
    // I made this 16, not 60, so the total time would be 20 sec. 
    for(int i = 0; i < 16; i++){ 
80 func5(); 
    } 
    } 

où chaque func() un Sleep(1000) et ne fait qqq est vrai, si la chose fonctionne pendant 20 secondes. Les chiffres sur la gauche sont le pourcentage d'échantillons (6667 échantillons) qui ont cette ligne sur eux. Par exemple, un appel unique à l'une des fonctions func utilise 1 seconde ou 5% du temps total. Ainsi, vous pouvez voir que la ligne où est appelé func5() utilise 80% du temps total. (C'est-à-dire, 16 sur les 20 secondes.) Toutes les autres lignes étaient si peu, comparativement, que leurs pourcentages étaient nuls.

Je présenterais l'information différemment, mais cela devrait donner une idée de ce que l'échantillonnage de la pile peut vous dire.

2

gprof est assez standard pour GNU construit (gcc, g ++) programmes: http://www.cs.utah.edu/dept/old/texinfo/as/gprof_toc.html

Voici ce que la sortie ressemble à: http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html#SEC5

+0

Je ne vois pas le code source annoté sur ce lien. –

+2

Exemple de source annotée: http://sourceware.org/binutils/docs/gprof/Annotated-Source.html – kanaka

+0

Peut-il calculer des délais réels (par exemple, en attente d'une entrée), et pas seulement combien de fois chaque chose est appelée? Je l'ai essayé sur un programme simple qui appelle sleep (10000), mais gprof ne parvient pas à détecter les retards du tout. –