Comme je n'ai rien vu ici sur perfun outil relativement nouveau de profilage du noyau et des applications utilisateur sous Linux, j'ai décidé d'ajouter ces informations.
Tout d'abord - ceci est un tutoriel sur le profilage Linux avecperf
Vous pouvez utiliser perfsi votre noyau Linux est supérieur à 2.6.32 ou oprofiles'il est plus ancien. Les deux programmes ne nécessitent pas de votre part d'instrumenter votre programme (comme le gprofrequiert). Cependant, pour obtenir correctement le graphe d'appel, perfvous devez créer votre programme avec -fno-omit-frame-pointer. Par exemple: g++ -fno-omit-frame-pointer -O2 main.cpp.
Vous pouvez voir l'analyse "en direct" de votre application avec perf top:
sudo perf top -p `pidof a.out` -K
Ou vous pouvez enregistrer les données de performance d'une application en cours d'exécution et les analyser après cela:
1) Pour enregistrer les données de performance:
perf record -p `pidof a.out`
ou pour enregistrer pendant 10 secondes:
perf record -p `pidof a.out` sleep 10
ou pour enregistrer avec call graph ()
perf record -g -p `pidof a.out`
2) Pour analyser les données enregistrées
perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g
Ou vous pouvez enregistrer les données de performance d'une application et les analyser ensuite simplement en lançant l'application de cette manière et en attendant qu'elle se termine:
perf record ./a.out
Ceci est un exemple de profilage d'un programme de test
Le programme de test est dans le fichier main.cpp (je mettrai main.cpp en bas du message):
Je le compile de cette manière:
g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test
J'utilise libmalloc_minimial.socar il est compilé avec -fno-omit-frame-pointertandis que la libc malloc semble être compilée sans cette option. Ensuite, je lance mon programme de test
./my_test 100000000
Ensuite, j'enregistre les données de performance d'un processus en cours:
perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30
Ensuite, j'analyse la charge par module:
rapport de perf --stdio -g aucun --sort comm, dso -i ./my_test.perf.data
# Overhead Command Shared Object
# ........ ....... ............................
#
70.06% my_test my_test
28.33% my_test libtcmalloc_minimal.so.0.1.0
1.61% my_test [kernel.kallsyms]
Ensuite, la charge par fonction est analysée:
rapport de perf --stdio -g aucun -i ./my_test.perf.data | c ++ filt
# Overhead Command Shared Object Symbol
# ........ ....... ............................ ...........................
#
29.30% my_test my_test [.] f2(long)
29.14% my_test my_test [.] f1(long)
15.17% my_test libtcmalloc_minimal.so.0.1.0 [.] operator new(unsigned long)
13.16% my_test libtcmalloc_minimal.so.0.1.0 [.] operator delete(void*)
9.44% my_test my_test [.] process_request(long)
1.01% my_test my_test [.] operator delete(void*)@plt
0.97% my_test my_test [.] operator new(unsigned long)@plt
0.20% my_test my_test [.] main
0.19% my_test [kernel.kallsyms] [k] apic_timer_interrupt
0.16% my_test [kernel.kallsyms] [k] _spin_lock
0.13% my_test [kernel.kallsyms] [k] native_write_msr_safe
and so on ...
Ensuite, les chaînes d'appels sont analysées:
rapport perf --stdio -g graph -i ./my_test.perf.data | c ++ filt
# Overhead Command Shared Object Symbol
# ........ ....... ............................ ...........................
#
29.30% my_test my_test [.] f2(long)
|
--- f2(long)
|
--29.01%-- process_request(long)
main
__libc_start_main
29.14% my_test my_test [.] f1(long)
|
--- f1(long)
|
|--15.05%-- process_request(long)
| main
| __libc_start_main
|
--13.79%-- f2(long)
process_request(long)
main
__libc_start_main
15.17% my_test libtcmalloc_minimal.so.0.1.0 [.] operator new(unsigned long)
|
--- operator new(unsigned long)
|
|--11.44%-- f1(long)
| |
| |--5.75%-- process_request(long)
| | main
| | __libc_start_main
| |
| --5.69%-- f2(long)
| process_request(long)
| main
| __libc_start_main
|
--3.01%-- process_request(long)
main
__libc_start_main
13.16% my_test libtcmalloc_minimal.so.0.1.0 [.] operator delete(void*)
|
--- operator delete(void*)
|
|--9.13%-- f1(long)
| |
| |--4.63%-- f2(long)
| | process_request(long)
| | main
| | __libc_start_main
| |
| --4.51%-- process_request(long)
| main
| __libc_start_main
|
|--3.05%-- process_request(long)
| main
| __libc_start_main
|
--0.80%-- f2(long)
process_request(long)
main
__libc_start_main
9.44% my_test my_test [.] process_request(long)
|
--- process_request(long)
|
--9.39%-- main
__libc_start_main
1.01% my_test my_test [.] operator delete(void*)@plt
|
--- operator delete(void*)@plt
0.97% my_test my_test [.] operator new(unsigned long)@plt
|
--- operator new(unsigned long)@plt
0.20% my_test my_test [.] main
0.19% my_test [kernel.kallsyms] [k] apic_timer_interrupt
0.16% my_test [kernel.kallsyms] [k] _spin_lock
and so on ...
Donc, à ce stade, vous savez où votre programme passe du temps.
Et voici main.cpp pour le test:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
time_t f1(time_t time_value)
{
for (int j =0; j < 10; ++j) {
++time_value;
if (j%5 == 0) {
double *p = new double;
delete p;
}
}
return time_value;
}
time_t f2(time_t time_value)
{
for (int j =0; j < 40; ++j) {
++time_value;
}
time_value=f1(time_value);
return time_value;
}
time_t process_request(time_t time_value)
{
for (int j =0; j < 10; ++j) {
int *p = new int;
delete p;
for (int m =0; m < 10; ++m) {
++time_value;
}
}
for (int i =0; i < 10; ++i) {
time_value=f1(time_value);
time_value=f2(time_value);
}
return time_value;
}
int main(int argc, char* argv2[])
{
int number_loops = argc > 1 ? atoi(argv2[1]) : 1;
time_t time_value = time(0);
printf("number loops %d\n", number_loops);
printf("time_value: %d\n", time_value );
for (int i =0; i < number_loops; ++i) {
time_value = process_request(time_value);
}
printf("time_value: %ld\n", time_value );
return 0;
}