Instructions de traçage / profilage

Je voudrais statistiquement profiler mon code C au niveau de l’instruction. J’ai besoin de savoir combien d’ajouts, de multiplications, de divisions, etc. je joue.

Ce n’est pas votre profil habituel de profilage de code d’usine. Je suis un développeur d’algorithmes et je souhaite estimer le coût de la conversion de mon code en implémentations matérielles. Pour cela, on me demande la répartition des instructions lors de l’exécution (l’parsing de l’assembly compilé ne suffit pas car elle ne prend pas en compte les boucles dans le code).

Après avoir regardé autour de nous, il semble que VMware offre une solution possible, mais je n’ai toujours pas trouvé la fonctionnalité spécifique qui me permettrait de suivre le stream d’appels d’instructions de mon processus.

Connaissez-vous des outils de profilage qui permettent cela?

J’ai finalement utilisé une solution simple mais efficace.

  1. GDB configuré pour afficher le désassemblage de l’instruction suivante (à chaque fois qu’elle s’arrête) en invoquant:

display/i $pc

  1. Configuré un script gdb simple qui rompt la fonction que j’ai besoin d’parsingr et passe à l’instruction étape par étape:

      set $ i = 0
     pause principale
     courir
     tandis que (i $ 100000)
     si
     set $ i = $ i + 1
     fin
     quitter
    

  2. Gdb exécuté avec la sortie de mon script dans un fichier journal:

    gdb -x script a.out > log.txt

  3. Analysé le journal pour compter les appels d’instruction spécifiques.

Brut, mais ça marche …

Vous pouvez utiliser pin-instat qui est un outil de code PIN. C’est un peu trop fatal car il enregistre plus d’informations que le nombre d’instructions. Cela devrait quand même être plus efficace que votre approche gdb.

Disclaimer: Je suis l’auteur de pin-instat.

L’outil valgrind cachegrind peut être utilisé pour obtenir le nombre d’exécutions de chaque ligne de l’assemblage compilé (la valeur Ir dans la première colonne).

L’outil Linux perf fournira beaucoup d’informations de profilage; perf annotate précisément, perf annotate vous donnera des comptes relatifs par instruction.

Il est possible d’accéder au niveau d’instruction avec perf annotate . Pour cela, vous devez appeler perf annotate avec le nom de la commande à annoter. Toutes les fonctions avec des échantillons seront désassemblées et chaque instruction aura son pourcentage relatif d’échantillons rapporté:

 record de performance ./noploop 5
 perf annotate -d ./noploop

 ----------------------------------------------------
  Pour cent |  Code source et désassemblage de noploop.noggdb
 ----------------------------------------------------
          :
          :
          :
          : Déassembly de la section .text:
          :
          : 08048484 
: 0,00: 8048484: 55% push ebp 0.00: 8048485: 89 e5 mov% esp,% ebp [...] 0.00: 8048530: eb 0b jmp 804853d 15.08: 8048532: 8b 44 24 2c mov 0x2c (% esp),% eax 0.00: 8048536: 83 c0 01 append $ 0x1,% eax 14.52: 8048539: 89 44 24 2c mov% eax, 0x2c (% esp) 14.27: 804853d: 8b 44 24 2c mov 0x2c (% esp),% eax 56.13: 8048541: 3d ff e0 f5 05 cmp $ 0x5f5e0ff,% eax 0.00: 8048546: 76 ea jbe 8048532
[...]