සී ++ පැතිකඩ ශිල්ප ක්‍රම සමීක්ෂණය
මෙම පිළිතුරේ දී, එම මෙවලම් ක්‍රියා කරන ආකාරය සංක්ෂිප්තව සංසන්දනය කිරීම සඳහා ඉතා සරල පරීක්ෂණ වැඩසටහන් කිහිපයක් විශ්ලේෂණය කිරීමට මම විවිධ මෙවලම් කිහිපයක් භාවිතා කරමි.
පහත දැක්වෙන පරීක්ෂණ වැඩසටහන ඉතා සරල වන අතර පහත සඳහන් දේ කරයි:
mainඇමතුම් fastසහ maybe_slow3 වතාවක්, එක් maybe_slowඇමතුමක් මන්දගාමී වේ
මන්දගාමී ඇමතුම maybe_slow10x දිගු වන අතර, ළමා ක්‍රියාකාරිත්වයට ඇමතුම් සලකා බැලුවහොත් ධාවන වේලාවේ ආධිපත්‍යය දරයි common. ඉතා මැනවින්, පැතිකඩ මෙවලමට නිශ්චිත මන්දගාමී ඇමතුම වෙත අපව යොමු කිරීමට හැකි වනු ඇත.
දෙකම fastසහ maybe_slowඇමතුම common, එය වැඩසටහන ක්රියාත්මක කිරීමේ වැඩි කොටසක් සඳහා හේතු වේ
වැඩසටහන් අතුරුමුහුණත:
./main.out [n [seed]]
වැඩසටහන O(n^2)සම්පුර්ණයෙන්ම ලූප කරයි. seedධාවන කාලයට බලපෑමක් නොකර විවිධ ප්‍රතිදානයන් ලබා ගැනීම පමණි.
main.c
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
uint64_t __attribute__ ((noinline)) common(uint64_t n, uint64_t seed) {
for (uint64_t i = 0; i < n; ++i) {
seed = (seed * seed) - (3 * seed) + 1;
}
return seed;
}
uint64_t __attribute__ ((noinline)) fast(uint64_t n, uint64_t seed) {
uint64_t max = (n / 10) + 1;
for (uint64_t i = 0; i < max; ++i) {
seed = common(n, (seed * seed) - (3 * seed) + 1);
}
return seed;
}
uint64_t __attribute__ ((noinline)) maybe_slow(uint64_t n, uint64_t seed, int is_slow) {
uint64_t max = n;
if (is_slow) {
max *= 10;
}
for (uint64_t i = 0; i < max; ++i) {
seed = common(n, (seed * seed) - (3 * seed) + 1);
}
return seed;
}
int main(int argc, char **argv) {
uint64_t n, seed;
if (argc > 1) {
n = strtoll(argv[1], NULL, 0);
} else {
n = 1;
}
if (argc > 2) {
seed = strtoll(argv[2], NULL, 0);
} else {
seed = 0;
}
seed += maybe_slow(n, seed, 0);
seed += fast(n, seed);
seed += maybe_slow(n, seed, 1);
seed += fast(n, seed);
seed += maybe_slow(n, seed, 0);
seed += fast(n, seed);
printf("%" PRIX64 "\n", seed);
return EXIT_SUCCESS;
}
gprof
gprof සඳහා මෘදුකාංගය උපකරණ සමඟ නැවත සකස් කිරීම අවශ්‍ය වන අතර, එම උපකරණ සමඟ නියැදි ප්‍රවේශයක් ද භාවිතා කරයි. එබැවින් එය නිරවද්‍යතාව අතර සමතුලිතතාවයක් ඇති කරයි (නියැදීම සැමවිටම සම්පූර්ණයෙන් නිවැරදි නොවන අතර කාර්යයන් මඟ හැරිය හැක) සහ ක්රියාත්මක කිරීමේ මන්දගාමී වීම (උපකරණ සහ නියැදීම සාපේක්ෂව වේගවත් ක්‍රමවේදයන් වන අතර එය ක්රියාත්මක කිරීම මන්දගාමී නොවේ).
gprof GCC / binutils තුළ ගොඩනගා ඇත, එබැවින් අප කළ යුතුව ඇත්තේ -pggprof සක්‍රීය කිරීමේ විකල්පය සමඟ සම්පාදනය කිරීමයි. තත්පර කිහිපයක ( 10000) සාධාරණ කාල සීමාවක් ධාවනය කරන ප්‍රමාණයේ CLI පරාමිතියකින් අපි සාමාන්‍යයෙන් වැඩසටහන ක්රියාත්මක කරන්නෙමු :
gcc -pg -ggdb3 -O3 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
time ./main.out 10000
අධ්‍යාපනික හේතූන් මත, අපි ප්‍රශස්තිකරණය සක්‍රීය නොකර ධාවනය කරන්නෙමු. ප්‍රායෝගිකව මෙය නිෂ් less ල බව සලකන්න, ඔබ සාමාන්‍යයෙන් සැලකිලිමත් වන්නේ ප්‍රශස්තිකරණය කළ වැඩසටහනේ ක්‍රියාකාරිත්වය ප්‍රශස්ත කිරීම ගැන පමණි:
gcc -pg -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
./main.out 10000
පළමුවෙන්ම, timeඅපට කියනුයේ ක්රියාත්මක කිරීමේ කාලය හා රහිතව -pgඑක හා සමාන බවයි, එය විශිෂ්ටයි: මන්දගාමී වීමක් නැත! කෙසේ වෙතත්, සංකීර්ණ මෘදුකාංගවල 2x - 3x මන්දගාමී වීමේ ගිණුම් මම දැක ඇත්තෙමි, උදා: මෙම ප්‍රවේශ පත්‍රයේ පෙන්වා ඇති පරිදි .
අප සම්පාදනය කළ නිසා -pg, වැඩසටහන ක්රියාත්මක gmon.outකිරීමෙන් පැතිකඩ දත්ත අඩංගු ගොනු ගොනුවක් නිපදවයි .
gprof2dotඉල්ලූ පරිදි අපට එම ගොනුව ප්‍රස්ථාරිකව නිරීක්ෂණය කළ හැකිය : gprof ප්‍රති results ලවල චිත්‍රමය නිරූපණයක් ලබා ගත හැකිද?
sudo apt install graphviz
python3 -m pip install --user gprof2dot
gprof main.out > main.gprof
gprof2dot < main.gprof | dot -Tsvg -o output.svg
මෙතන, gprofමෙවලමක් කියවන gmon.outහෝඩුවාවක් තොරතුරු, සහ මානව කියවිය හැකි වාර්තාව ජනනය main.gprofවන gprof2dotපසුව ප්රස්ථාරයක් උත්පාදනය කිරීමට කියවනවා.
Gprof2dot සඳහා ප්‍රභවය වන්නේ: https://github.com/jrfonseca/gprof2dot
-O0ධාවනය සඳහා අපි පහත සඳහන් දෑ නිරීක්ෂණය කරමු :
සහ -O3ධාවනය සඳහා:
මෙම -O0ප්රතිදානය එච්චරමයි ස්වයං පැහැදිලි වේ. නිදසුනක් ලෙස, maybe_slowඇමතුම් 3 සහ ඔවුන්ගේ ළමා ඇමතුම් මුළු ධාවන කාලයෙන් 97.56% ක් ගන්නා බව පෙන්නුම් කරයි , නමුත් maybe_slowළමයින් නොමැතිව ක්රියාත්මක කිරීම මුළු ක්රියාත්මක කිරීමේ වේලාවෙන් 0.00% ක් පමණ වේ, එනම් එම කාර්යයේ ගත කළ මුළු කාලයම පාහේ වැය කර ඇත ළමා ඇමතුම්.
ටෝඩෝ: ජීඩීබී හි මට එය දැකිය හැකි වුවද, නිමැවුමේ mainඅස්ථානගත වී ඇත්තේ ඇයි ? GProf නිමැවුමේ ක්‍රියාකාරිත්වය අස්ථානගත වී ඇත්තේ එයට හේතුව gprof ද එහි සම්පාදනය කරන ලද උපකරණවලට අමතරව නියැදි කිරීම වන අතර එය ඉතා වේගවත් වන අතර සාම්පල කිසිවක් නොලැබුණි.-O3bt-O3 main
මම PNG වෙනුවට SVG ප්රතිදානය තෝරා ගන්නේ SVG Ctrl + F සමඟ සෙවිය හැකි නිසා සහ ගොනු ප්‍රමාණය 10x පමණ කුඩා විය හැකි බැවිනි. එසේම, ජනනය කරන ලද රූපයේ පළල සහ උස සංකීර්ණ මෘදුකාංග සඳහා පික්සල් දස දහස් ගණනක් සමඟ නිහතමානී විය හැකි අතර, පීඑන්ජී සඳහා GNOME eog3.28.1 දෝෂ ඇති වන අතර, එස්වීජී ස්වයංක්‍රීයව මගේ බ්‍රව්සරයෙන් විවෘත වේ. gimp 2.8 හොඳින් ක්‍රියා කළද මෙයද බලන්න:
නමුත් එසේ වුවද, ඔබට අවශ්‍ය දේ සොයා ගැනීම සඳහා ඔබ රූපය බොහෝ දුරට ඇදගෙන යනු ඇත, උදා : මෙම ටිකට් පතෙන් ලබාගත් “සැබෑ” මෘදුකාංග උදාහරණයකින් මෙම රූපය බලන්න :
ඉතා කුඩා වර්ගීකරණය නොකළ ස්පැගටි රේඛා එකිනෙක හරහා ගමන් කිරීමෙන් ඔබට වඩාත් විවේචනාත්මක ඇමතුම් තොගය පහසුවෙන් සොයාගත හැකිද? dotමට විශ්වාසයි වඩා හොඳ විකල්ප තිබිය හැකිය , නමුත් මට දැන් එහි යාමට අවශ්‍ය නැත. අපට සැබවින්ම අවශ්‍ය වන්නේ ඒ සඳහා නිසි කැපවූ නරඹන්නෙකු පමණි, නමුත් මම තවම එකක් සොයාගෙන නැත:
කෙසේ වෙතත් ඔබට වර්ණ සිතියම භාවිතා කර එම ගැටළු ටිකක් අවම කර ගත හැකිය. නිදසුනක් ලෙස, පෙර දැවැන්ත රූපය මත, කොළ පාටින් රතු පැහැයෙන් පසුව පැමිණෙන බව දීප්තිමත් අඩු කිරීමක් කළ විට වම් පසින් තීරණාත්මක මාවත සොයා ගැනීමට මට හැකි විය.
විකල්පයක් ලෙස, අප විසින් gprofමීට පෙර සුරකින ලද බිල්ට් බිනූටිල්ස් මෙවලමෙහි පෙළ ප්රතිදානය ද නිරීක්ෂණය කළ හැකිය :
cat main.gprof
පෙරනිමියෙන්, මෙය ප්රතිදාන දත්තවල තේරුම පැහැදිලි කරන අතිශය වාචික ප්‍රතිදානයක් නිපදවයි. මට ඊට වඩා හොඳින් පැහැදිලි කළ නොහැකි බැවින්, මම එය ඔබටම කියවීමට ඉඩ දෙමි.
දත්ත ප්රතිදාන ආකෘතිය ඔබ තේරුම් ගත් පසු, නිබන්ධනය නොමැතිව දත්ත පමණක් පෙන්වීමට ඔබට වාචිකතාව අඩු කළ -bහැකිය:
gprof -b main.out
අපගේ උදාහරණයේ දී, ප්‍රතිදානයන් සඳහා -O0:
Flat profile:
Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls s/call s/call name
100.35 3.67 3.67 123003 0.00 0.00 common
0.00 3.67 0.00 3 0.00 0.03 fast
0.00 3.67 0.00 3 0.00 1.19 maybe_slow
Call graph
granularity: each sample hit covers 2 byte(s) for 0.27% of 3.67 seconds
index % time self children called name
0.09 0.00 3003/123003 fast [4]
3.58 0.00 120000/123003 maybe_slow [3]
[1] 100.0 3.67 0.00 123003 common [1]
-----------------------------------------------
<spontaneous>
[2] 100.0 0.00 3.67 main [2]
0.00 3.58 3/3 maybe_slow [3]
0.00 0.09 3/3 fast [4]
-----------------------------------------------
0.00 3.58 3/3 main [2]
[3] 97.6 0.00 3.58 3 maybe_slow [3]
3.58 0.00 120000/123003 common [1]
-----------------------------------------------
0.00 0.09 3/3 main [2]
[4] 2.4 0.00 0.09 3 fast [4]
0.09 0.00 3003/123003 common [1]
-----------------------------------------------
Index by function name
[1] common [4] fast [3] maybe_slow
සහ සඳහා -O3:
Flat profile:
Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls us/call us/call name
100.52 1.84 1.84 123003 14.96 14.96 common
Call graph
granularity: each sample hit covers 2 byte(s) for 0.54% of 1.84 seconds
index % time self children called name
0.04 0.00 3003/123003 fast [3]
1.79 0.00 120000/123003 maybe_slow [2]
[1] 100.0 1.84 0.00 123003 common [1]
-----------------------------------------------
<spontaneous>
[2] 97.6 0.00 1.79 maybe_slow [2]
1.79 0.00 120000/123003 common [1]
-----------------------------------------------
<spontaneous>
[3] 2.4 0.00 0.04 fast [3]
0.04 0.00 3003/123003 common [1]
-----------------------------------------------
Index by function name
[1] common
එක් එක් කොටස සඳහා ඉතා ඉක්මන් සාරාංශයක් ලෙස උදා:
0.00 3.58 3/3 main [2]
[3] 97.6 0.00 3.58 3 maybe_slow [3]
3.58 0.00 120000/123003 common [1]
ඉන්ඩෙන්ට් කර ඇති ශ්‍රිතය වටා කේන්ද්‍රගත වේ ( maybe_flow). [3]යනු එම ශ්‍රිතයේ හැඳුනුම්පතයි. ශ්‍රිතයට ඉහළින්, එහි අමතන්නන් වන අතර, ඊට පහළින් ඇමතුම් ලබා ගනී.
සඳහා -O3, එම චිත්රම ප්රතිදාන වගේ මෙතන බලන්න maybe_slowසහ fastලේඛගතකිරීම බව කියන දේ වන ප්රසිද්ධ මව් නැති <spontaneous>මාධ්යයක්.
Gprof සමඟ රේඛීය-පැතිකඩ පැතිකඩ කිරීමට හොඳ ක්‍රමයක් තිබේදැයි මට විශ්වාස නැත: විශේෂිත කේත රේඛාවල `gprof` කාලය ගත කරයි
valgrind callgrind
valgrind විසින් වැඩසටහන ක්රියාත්මක කරන්නේ valgrind අථත්‍ය යන්ත්‍රය හරහාය. මෙය පැතිකඩ ඉතා නිවැරදි කරයි, නමුත් එය වැඩසටහනේ විශාල මන්දගාමිත්වයක් ද ඇති කරයි. මම මීට පෙර kcachegrind ගැනද සඳහන් කර ඇත්තෙමි: රූපමය ශ්‍රිත ඇමතුම් ප්රස්ථාරයක් ලබා ගැනීමේ මෙවලම්
callgrind යනු පැතිකඩ කේතයට වැල්ග්‍රින්ඩ්ගේ මෙවලම වන අතර kcachegrind යනු හැඹිලි ප්රතිදානය දෘශ්‍ය කළ හැකි KDE වැඩසටහනකි.
පළමුවෙන්ම අපි -pgසාමාන්‍ය සම්පාදනය වෙත යාමට ධජය ඉවත් කළ යුතුය, එසේ නොමැති නම් ධාවනය ඇත්ත වශයෙන්ම අසමත් වේ Profiling timer expired, ඔව්, මෙය මා විසින් කරන ලද තරම් පොදු වන අතර ඒ සඳහා ස්ටක් පිටාර ගැලීමේ ප්‍රශ්නයක් තිබුණි.
එබැවින් අපි සම්පාදනය කර ක්රියාත්මක වන්නේ:
sudo apt install kcachegrind valgrind
gcc -ggdb3 -O3 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
time valgrind --tool=callgrind valgrind --dump-instr=yes \
--collect-jumps=yes ./main.out 10000
--dump-instr=yes --collect-jumps=yesඑකලස් කිරීමේ කාර්ය සාධනය බිඳවැටීම සාපේක්ෂව කුඩා අමතර පොදු කාර්ය පිරිවැයකින් බැලීමට අපට හැකි වන පරිදි මෙය තොරතුරු සක්‍රීය කරයි.
වවුලා ලකුණු, timeඅපට පවසනවා වැඩසටහන අපි මෙම උදාහරණය මගින් 15x පමණ මන්දගාමී වීම සිදු එසේ, ක්රියාත්මක කිරීමට තත්පර 29.5 වූ බව. පැහැදිලිවම, මෙම මන්දගාමිත්වය විශාල වැඩ බරක් සඳහා බරපතල සීමාවක් වනු ඇත. මෙහි සඳහන් "තාත්වික ලෝක මෘදුකාංග උදාහරණයේ" , 80x හි මන්දගාමිත්වයක් මම නිරීක්ෂණය කළෙමි.
ධාවනය මගේ නඩුවේ callgrind.out.<pid>උදා callgrind.out.8554. නම් පැතිකඩ දත්ත ගොනුවක් ජනනය කරයි . අපි එම ගොනුව පහත පරිදි බලමු:
kcachegrind callgrind.out.8554
පා g මය gprof ප්‍රතිදානයට සමාන දත්ත අඩංගු GUI එකක් පෙන්වන:
එසේම, අපි පහළ දකුණේ “කෝල් ප්‍රස්තාරය” ටැබයට ගියහොත්, අපට අසාමාන්‍ය ලෙස සුදු මායිම් සහිත පහත රූපය ලබා ගැනීම සඳහා දකුණු ක්ලික් කිරීමෙන් අපනයනය කළ හැකි ඇමතුම් ප්රස්ථාරයක් අපට පෙනේ :-)
මම හිතන්නේ fastඑම ප්‍රස්ථාරයේ පෙන්වන්නේ නැති නිසා kcachegrind දෘශ්‍යකරණය සරල කර තිබිය යුතු නිසා එම ඇමතුමට වැඩි කාලයක් ගත වන බැවින් මෙය සැබෑ වැඩසටහනක ඔබට අවශ්‍ය හැසිරීම විය හැකිය. දකුණු ක්ලික් මෙනුවෙහි එවැනි නෝඩ් ඉවත් කළ යුත්තේ කවදාදැයි පාලනය කිරීමට යම් සැකසුම් ඇත, නමුත් ඉක්මන් උත්සාහයකින් පසු එවැනි කෙටි ඇමතුමක් පෙන්වීමට මට එය ලබා ගත නොහැකි විය. මම fastවම් කවුළුව මත ක්ලික් කළහොත් , එය සමඟ ඇමතුම් ප්රස්ථාරයක් පෙන්වයි fast, එවිට එම තොගය සැබවින්ම ග්‍රහණය කර ගන්නා ලදි. සම්පුර්ණ ප්‍රස්ථාර ඇමතුම් ප්‍රස්ථාරය පෙන්වීමට කිසිවෙකු මෙතෙක් ක්‍රමයක් සොයාගෙන නැත: kcachegrind ඇමතුම් සටහනේ ඇති සියලුම ක්‍රියාකාරී ඇමතුම් පෙන්වීමට callgrind කරන්න.
සංකීර්ණ C ++ මෘදුකාංග මත TODO, මම යම් ආකාරයක ඇතුළත් කිරීම් දකිමි <cycle N>, උදා: <cycle 11>මම ක්‍රියාකාරී නම් බලාපොරොත්තු වන තැන, එයින් අදහස් කරන්නේ කුමක්ද? එය සක්‍රිය හා අක්‍රිය කිරීමට "පාපැදි අනාවරණය" බොත්තමක් ඇති බව මම දුටුවෙමි, නමුත් එයින් අදහස් කරන්නේ කුමක්ද?
perf සිට linux-tools
perfලිනක්ස් කර්නල් නියැදි යාන්ත්‍රණ පමණක් භාවිතා කරන බව පෙනේ. මෙය සැකසීමට ඉතා සරල වන අතර එය සම්පූර්ණයෙන්ම නිවැරදි නොවේ.
sudo apt install linux-tools
time perf record -g ./main.out 10000
මෙය ක්රියාත්මක කිරීම සඳහා තත්පර 0.2 ක් එකතු කරන ලදි, එබැවින් අපි කාලය නැණවත් ය, නමුත් commonයතුරුපුවරුවේ දකුණු ඊතලය සමඟ නෝඩය පුළුල් කිරීමෙන් පසුව මම තවමත් වැඩි උනන්දුවක් නොදක්වමි :
Samples: 7K of event 'cycles:uppp', Event count (approx.): 6228527608
Children Self Command Shared Object Symbol
- 99.98% 99.88% main.out main.out [.] common
common
0.11% 0.11% main.out [kernel] [k] 0xffffffff8a6009e7
0.01% 0.01% main.out [kernel] [k] 0xffffffff8a600158
0.01% 0.00% main.out [unknown] [k] 0x0000000000000040
0.01% 0.00% main.out ld-2.27.so [.] _dl_sysdep_start
0.01% 0.00% main.out ld-2.27.so [.] dl_main
0.01% 0.00% main.out ld-2.27.so [.] mprotect
0.01% 0.00% main.out ld-2.27.so [.] _dl_map_object
0.01% 0.00% main.out ld-2.27.so [.] _xstat
0.00% 0.00% main.out ld-2.27.so [.] __GI___tunables_init
0.00% 0.00% main.out [unknown] [.] 0x2f3d4f4944555453
0.00% 0.00% main.out [unknown] [.] 0x00007fff3cfc57ac
0.00% 0.00% main.out ld-2.27.so [.] _start
ඒ නිසා මම එය -O0කිසියම් දෙයක් පෙන්වන්නේ දැයි බැලීමට වැඩසටහනේ මිණුම් සලකුණු කිරීමට උත්සාහ කරමි , දැන් පමණක්, අවසානයේදී මට ඇමතුම් ප්රස්ථාරයක් පෙනේ:
Samples: 15K of event 'cycles:uppp', Event count (approx.): 12438962281
Children Self Command Shared Object Symbol
+ 99.99% 0.00% main.out [unknown] [.] 0x04be258d4c544155
+ 99.99% 0.00% main.out libc-2.27.so [.] __libc_start_main
- 99.99% 0.00% main.out main.out [.] main
- main
- 97.54% maybe_slow
common
- 2.45% fast
common
+ 99.96% 99.85% main.out main.out [.] common
+ 97.54% 0.03% main.out main.out [.] maybe_slow
+ 2.45% 0.00% main.out main.out [.] fast
0.11% 0.11% main.out [kernel] [k] 0xffffffff8a6009e7
0.00% 0.00% main.out [unknown] [k] 0x0000000000000040
0.00% 0.00% main.out ld-2.27.so [.] _dl_sysdep_start
0.00% 0.00% main.out ld-2.27.so [.] dl_main
0.00% 0.00% main.out ld-2.27.so [.] _dl_lookup_symbol_x
0.00% 0.00% main.out [kernel] [k] 0xffffffff8a600158
0.00% 0.00% main.out ld-2.27.so [.] mmap64
0.00% 0.00% main.out ld-2.27.so [.] _dl_map_object
0.00% 0.00% main.out ld-2.27.so [.] __GI___tunables_init
0.00% 0.00% main.out [unknown] [.] 0x552e53555f6e653d
0.00% 0.00% main.out [unknown] [.] 0x00007ffe1cf20fdb
0.00% 0.00% main.out ld-2.27.so [.] _start
ටෝඩෝ: -O3මරණ ද on ුවම ක්රියාත්මක වූයේ කුමක් ද ? එය සරලවම maybe_slowහා fastවේගවත් වූ අතර සාම්පල කිසිවක් නොලැබුණි ද? -O3ක්රියාත්මක කිරීමට වැඩි කාලයක් ගතවන විශාල වැඩසටහන් සමඟ එය හොඳින් ක්රියාත්මක වේද? මට CLI විකල්පයක් මග හැරුණාද? -Fහර්ට්ස් හි නියැදි සංඛ්යාතය පාලනය කිරීමට මම සොයා ගත්තෙමි , නමුත් මම එය පෙරනිමියෙන් අවසර දී ඇති උපරිමයට හරවා -F 39500(වැඩි කළ හැකිය sudo) සහ මට තවමත් පැහැදිලි ඇමතුම් නොපෙනේ.
මෙහි ඇති එක් සිසිල් දෙයක් perfනම් බ්‍රෙන්ඩන් ග්‍රෙග්ගේ ෆ්ලේම් ග්‍රාෆ් මෙවලමයි. එමඟින් ඇමතුම් සිරස් වේලාවන් ඉතා පිළිවෙලට ප්‍රදර්ශනය කර ඔබට විශාල ඇමතුම් ඉක්මනින් දැක ගත හැකිය. මෙම මෙවලම ලබා ගත හැක: https://github.com/brendangregg/FlameGraph ද ඔහුගේ perf නිබන්ධන මත සඳහන් කර ඇත: http://www.brendangregg.com/perf.html#FlameGraphs මම දුවන විට perfතොරව sudoමට ලැබුණ ERROR: No stack counts foundසඳහා එසේ දැන් මම එය කරන්නේ sudo:
git clone https://github.com/brendangregg/FlameGraph
sudo perf record -F 99 -g -o perf_with_stack.data ./main.out 10000
sudo perf script -i perf_with_stack.data | FlameGraph/stackcollapse-perf.pl | FlameGraph/flamegraph.pl > flamegraph.svg
නමුත් එවැනි සරල වැඩසටහනක ප්රතිදානය තේරුම් ගැනීම එතරම් පහසු නැත, මන්ද අපට පහසුවෙන් maybe_slowහෝ fastඑම ප්‍රස්ථාරයේ නොපෙනේ :
වඩාත් සංකීර්ණ උදාහරණයකින් ප්‍රස්ථාරයේ තේරුම පැහැදිලි වේ:
TODO [unknown]එම උදාහරණයේ කාර්යයන් රාශියක් ඇත, එය එසේ වන්නේ ඇයි?
එය වටින තවත් පරිපූර්ණ GUI අතුරුමුහුණත් ඇතුළත් වේ:
Eclipse Trace Compass ප්ලගිනය: https://www.eclipse.org/tracecompass/
නමුත් මෙහි ඇති අවාසිය නම්, ඔබ විසින් මුලින්ම පොදු හෝඩුවාවක් ආකෘතියට පරිවර්තනය කළ යුතු අතර, එය කළ හැකි perf data --to-ctfනමුත්, එය ගොඩනඟා ගත හැකි වේලාවට සක්‍රීය කළ යුතුය / perfප්‍රමාණවත් තරම් නව ඒවා තිබිය යුතුය , ඒ දෙකෙන් එකක්ම පරිපූර්ණත්වයට නොවේ උබුන්ටු 18.04
https://github.com/KDAB/hotspot
මෙහි අවාසිය නම් උබුන්ටු පැකේජයක් නොමැති බව පෙනෙන අතර එය තැනීම සඳහා Qt 5.10 ක් අවශ්‍ය වන අතර උබුන්ටු 18.04 Qt 5.9 හි පවතී.
gperftools
කලින් හැඳින්වූයේ "ගූගල් කාර්ය සාධන මෙවලම්", මූලාශ්‍රය: https://github.com/gperftools/gperftools නියැදි පදනම් කරගත්.
පළමුව gperftools සමඟ ස්ථාපනය කරන්න:
sudo apt install google-perftools
එවිට, අපට gperftools CPU පැතිකඩ ආකාර දෙකකින් සක්‍රීය කළ හැකිය: ධාවන වේලාවේදී හෝ ගොඩ නැගීමේ වේලාවේදී.
ධාවන වේලාවේදී, ඔබට සොයාගත හැකි LD_PRELOADලක්ෂ්‍යය වෙත යොමු libprofiler.soකළ යුතුය locate libprofiler.so, උදා: මගේ පද්ධතියේ:
gcc -ggdb3 -O3 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libprofiler.so \
CPUPROFILE=prof.out ./main.out 10000
විකල්පයක් ලෙස, අපට පුස්තකාලය සම්බන්ධක වේලාවට ගොඩනගා ගත හැකිය, LD_PRELOADධාවන වේලාවට ගමන් කිරීම බෙදා හරිනු ලැබේ:
gcc -Wl,--no-as-needed,-lprofiler,--as-needed -ggdb3 -O3 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
CPUPROFILE=prof.out ./main.out 10000
මෙයද බලන්න: gperftools - පැතිකඩ ගොනුව ඉවත දමා නැත
මා මෙතෙක් සොයාගෙන ඇති මෙම දත්ත බැලීමට ඇති හොඳම ක්රමය නම්, pcrof ප්රතිදානය kcachegrind ආදානය ලෙස ගන්නා එකම ආකෘතිය බවට පත් කිරීමයි (ඔව්, Valgrind-project-viewer-tool) සහ එය බැලීමට kcachegrind භාවිතා කරන්න:
google-pprof --callgrind main.out prof.out > callgrind.out
kcachegrind callgrind.out
එම ක්‍රම දෙකෙන් එකක් ධාවනය කිරීමෙන් පසුව, අපට prof.outපැතිකඩ දත්ත ගොනුවක් ප්රතිදානය ලෙස ලැබේ. අපට එම ගොනුව ප්‍රස්තාරිකව SVG ලෙස දැක්විය හැකිය:
google-pprof --web main.out prof.out
එය වෙනත් මෙවලම් මෙන් හුරුපුරුදු ඇමතුම් ප්රස්ථාරයක් ලෙස ලබා දෙයි, නමුත් තත්පරයට වඩා සාම්පල ගණනක විචක්ෂණ ඒකකය සමඟ.
විකල්පයක් ලෙස, අපට පහත පෙළ දත්ත කිහිපයක් ද ලබා ගත හැකිය:
google-pprof --text main.out prof.out
එය ලබා දෙන්නේ:
Using local file main.out.
Using local file prof.out.
Total: 187 samples
187 100.0% 100.0% 187 100.0% common
0 0.0% 100.0% 187 100.0% __libc_start_main
0 0.0% 100.0% 187 100.0% _start
0 0.0% 100.0% 4 2.1% fast
0 0.0% 100.0% 187 100.0% main
0 0.0% 100.0% 183 97.9% maybe_slow
මෙයද බලන්න: google perf මෙවලම් භාවිතා කරන්නේ කෙසේද
උබුන්ටු 18.04, gprof2dot 2019.11.30, valgrind 3.13.0, perf 4.15.18, Linux kernel 4.15.0, FLameGraph 1a0dc6985aad06e76857cf2a354bd5ba0c9ce96b, gperftools 2.5-2 හි පරීක්ෂා කර ඇත.
