Ponieważ nic tu nie widziałem perf co jest stosunkowo nowym narzędziem do profilowania jądra i aplikacji użytkownika w systemie Linux, postanowiłem dodać te informacje.
Po pierwsze - to jest tutorial o profilowaniu Linuksa zperf
Możesz użyć, perfjeśli twoje jądro Linuksa jest większe niż 2.6.32 lub oprofilejeśli jest starsze. Oba programy nie wymagają od ciebie instrumentowania twojego programu (jak gprofwymagania). Jednak aby poprawnie uzyskać wykres wywołań w programie perf, musisz zbudować swój program -fno-omit-frame-pointer. Na przykład:g++ -fno-omit-frame-pointer -O2 main.cpp .
Możesz zobaczyć analizę swojej aplikacji „na żywo” za pomocą perf top:
sudo perf top -p `pidof a.out` -K
Możesz też zarejestrować dane o wydajności uruchomionej aplikacji i przeanalizować je później:
1) Aby zarejestrować dane dotyczące wykonania:
perf record -p `pidof a.out`
lub nagrywać przez 10 sekund:
perf record -p `pidof a.out` sleep 10
lub nagrywać z wykresem wywołań ()
perf record -g -p `pidof a.out`
2) Analiza zarejestrowanych danych
perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g
Możesz też zarejestrować dane wydajności aplikacji i przeanalizować je po prostu uruchamiając aplikację w ten sposób i czekając na jej zamknięcie:
perf record ./a.out
To jest przykład profilowania programu testowego
Program testowy znajduje się w pliku main.cpp (umieszczę main.cpp na dole wiadomości):
Kompiluję to w ten sposób:
g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test
Używam, libmalloc_minimial.soponieważ jest kompilowany z, -fno-omit-frame-pointerpodczas gdy libc malloc wydaje się być kompilowany bez tej opcji. Następnie uruchamiam program testowy
./my_test 100000000
Następnie rejestruję dane wydajności uruchomionego procesu:
perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30
Następnie analizuję obciążenie na moduł:
raport perf --stdio -g none --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]
Następnie analizowane jest obciążenie na funkcję:
raport perf --stdio -g none -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 ...
Następnie analizowane są łańcuchy połączeń:
raport 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 ...
W tym momencie wiesz, gdzie Twój program spędza czas.
A to jest main.cpp do testu:
#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;
}