โปรแกรมอื่นทำอะไรเช่นเดียวกันกับ gprof
โปรแกรมอื่นทำอะไรเช่นเดียวกันกับ gprof
คำตอบ:
valgrindมี Profiler การเรียนการสอนนับกับ Visualizer ดีมากเรียกว่าKCacheGrind ตามที่ Mike Dunlavey แนะนำ Valgrind จะนับเศษของคำสั่งที่โพรเซสอยู่บนสแต็กถึงแม้ว่าฉันขอโทษที่พูดว่ามันดูสับสนในการเรียกซ้ำซึ่งกันและกัน แต่ Visualizer gprof
เป็นอย่างดีและปีแสงก่อน
gprof (อ่านกระดาษ)มีอยู่ด้วยเหตุผลทางประวัติศาสตร์ หากคุณคิดว่ามันจะช่วยให้คุณพบปัญหาด้านประสิทธิภาพก็ไม่เคยโฆษณาเช่นนี้ นี่คือสิ่งที่กระดาษพูดว่า:
โปรแกรมสามารถใช้ในการเปรียบเทียบและประเมินค่าใช้จ่ายของการใช้งานที่หลากหลาย
มันไม่ได้บอกว่ามันสามารถใช้เพื่อระบุการใช้งานต่าง ๆ ที่จะได้รับการประเมินแม้ว่ามันจะบอกเป็นนัยว่ามันสามารถทำได้ภายใต้สถานการณ์พิเศษ:
โดยเฉพาะอย่างยิ่งหากพบว่าส่วนเล็ก ๆ ของโปรแกรมควบคุมเวลาในการประมวลผล
ปัญหาเกี่ยวกับที่ไม่ได้แปลเป็ สิ่งเหล่านั้นไม่สำคัญหรือไม่? อย่าวางความคาดหวังกับgprofที่ไม่เคยอ้างสิทธิ์ มันเป็นเพียงเครื่องมือวัดและใช้งานกับ CPU เท่านั้น
ลองใช้วิธีนี้แทน
นี่คือตัวอย่างของการเร่งความเร็ว 44x
นี่คือการเร่งความเร็ว 730x
นี่คือการสาธิตวิดีโอ 8 นาที
นี่คือคำอธิบายของสถิติ
นี่คือคำตอบของการวิจารณ์
มีการสังเกตอย่างง่าย ๆ เกี่ยวกับโปรแกรม ในการดำเนินการที่กำหนดทุกคำสั่งจะรับผิดชอบบางส่วนของเวลาโดยรวม (โดยเฉพาะcall
คำแนะนำ) ในแง่ที่ว่าถ้ามันไม่ได้อยู่ที่นั่นเวลาจะไม่ถูกใช้ ในช่วงเวลานั้นคำสั่งจะอยู่ในสแต็ค ** เมื่อเข้าใจแล้วคุณจะเห็นว่า -
gprofคาดเดาตำนานบางอย่างเกี่ยวกับประสิทธิภาพเช่น:
การสุ่มตัวอย่างตัวนับโปรแกรมนั้นมีประโยชน์
มันจะมีประโยชน์ก็ต่อเมื่อคุณมีคอขวดฮอตสปอตที่ไม่จำเป็นเช่นการเรียงลำดับฟองของค่าสเกลาร์ขนาดใหญ่ ตัวอย่างเช่นทันทีที่คุณเปลี่ยนเป็นการจัดเรียงโดยใช้การเปรียบเทียบสตริงมันยังคงเป็นคอขวด แต่การสุ่มตัวอย่างโปรแกรมตัวนับจะไม่เห็นเพราะตอนนี้ฮอตสปอตอยู่ในการเปรียบเทียบแบบสตริง ในทางตรงกันข้ามถ้ามันเป็นตัวอย่างโปรแกรมเคาน์เตอร์ขยาย (สแตกการโทร) จุดที่เปรียบเทียบสตริงที่เรียกว่าห่วงการเรียงลำดับจะปรากฏขึ้นอย่างชัดเจน อันที่จริงแล้วgprofเป็นความพยายามที่จะแก้ไขข้อ จำกัด ของการสุ่มตัวอย่างแบบพีซีเท่านั้น
ฟังก์ชั่นเวลานั้นมีความสำคัญมากกว่าการจับเส้นรหัสที่ใช้เวลานาน
เหตุผลสำหรับตำนานนั้นคือgprofไม่สามารถจับภาพตัวอย่างสแต็กได้ดังนั้นแทนที่จะใช้ฟังก์ชันนับจำนวนการเรียกใช้และพยายามจับกราฟการโทร อย่างไรก็ตามเมื่อมีการระบุฟังก์ชั่นค่าใช้จ่ายสูงคุณยังคงต้องมองเข้าไปข้างในเพื่อหาเส้นที่รับผิดชอบเวลา หากมีตัวอย่างสแต็กที่คุณไม่ต้องการมองหาบรรทัดเหล่านั้นจะอยู่ในตัวอย่าง (ฟังก์ชั่นทั่วไปอาจมี 100 - 1,000 คำสั่งการเรียกใช้ฟังก์ชั่นคือ 1 คำสั่งดังนั้นสิ่งที่ตั้งค่าการโทรที่มีราคาสูงคือ 2-3 คำสั่งของขนาดที่แม่นยำยิ่งขึ้น)
กราฟการโทรมีความสำคัญ
สิ่งที่คุณต้องรู้เกี่ยวกับโปรแกรมไม่ใช่เวลาที่มันใช้เวลา แต่ทำไม. เมื่อมันใช้เวลาในฟังก์ชั่นทุกบรรทัดของโค้ดบนสแต็กจะมีลิงค์เดียวในห่วงโซ่ของเหตุผลว่าทำไมมันถึงมี หากคุณเห็นเพียงบางส่วนของสแต็คคุณจะเห็นได้เพียงบางส่วนของสาเหตุที่ทำให้คุณไม่สามารถบอกได้อย่างแน่นอนว่าเวลานั้นจำเป็นจริงๆหรือไม่ กราฟการโทรบอกอะไรคุณ แต่ละส่วนโค้งจะบอกคุณว่าบางฟังก์ชัน A อยู่ในกระบวนการของการเรียกใช้ฟังก์ชัน B บางส่วนของเวลา แม้ว่า A จะมีรหัสบรรทัดเดียวที่เรียกว่า B แต่บรรทัดนั้นจะให้เหตุผลเพียงเล็กน้อยเท่านั้น หากคุณโชคดีพออาจเป็นไปได้ว่าบรรทัดนั้นมีเหตุผลที่ไม่ดี โดยปกติคุณจะต้องเห็นหลายบรรทัดพร้อมกันเพื่อหาเหตุผลที่ไม่ดีหากมี ถ้า A โทร B ในที่มากกว่าหนึ่งแห่งมันจะบอกคุณน้อยลง
การเรียกซ้ำนั้นเป็นปัญหาที่ยุ่งยาก
นั่นเป็นเพียงเพราะgprofและ profilers อื่น ๆ รับรู้ถึงความต้องการในการสร้างกราฟการโทรและจากนั้นให้เวลากับโหนด หากมีตัวอย่างของสแต็คค่าใช้จ่ายเวลาของแต่ละบรรทัดของรหัสที่ปรากฏในตัวอย่างนั้นเป็นจำนวนที่ง่ายมาก - เศษส่วนของตัวอย่างที่เปิดอยู่ หากมีการเรียกซ้ำแล้วเส้นที่กำหนดสามารถปรากฏได้มากกว่าหนึ่งครั้งในตัวอย่าง
ไม่เป็นไร สมมติว่าตัวอย่างจะถูกนำมาทุก ๆ N ms และเส้นจะปรากฏบน F% ของพวกเขา (โดยลำพังหรือไม่) หากบรรทัดนั้นไม่สามารถใช้เวลา (เช่นโดยการลบหรือแยกรอบ) ตัวอย่างเหล่านั้นจะหายไปและเวลาจะลดลงโดย F%
ความแม่นยำของการวัดเวลา (และตัวอย่างจำนวนมาก) จึงมีความสำคัญ
ลองคิดดูสักครู่ หากบรรทัดของรหัสอยู่บน 3 ตัวอย่างจากห้าถ้าคุณสามารถยิงมันออกมาเหมือนหลอดไฟนั่นคือเวลาที่น้อยกว่าที่จะใช้ 60% ตอนนี้คุณรู้แล้วว่าถ้าคุณนำตัวอย่าง 5 ตัวอย่างที่แตกต่างกันคุณอาจเห็นเพียง 2 ครั้งหรือมากถึง 4 ดังนั้นการวัด 60% จะเหมือนกับช่วงทั่วไปจาก 40% ถึง 80% หากเป็นเพียง 40% คุณจะบอกว่าปัญหาไม่คุ้มค่าในการแก้ไขหรือไม่? ดังนั้นประเด็นของความแม่นยำของเวลาคืออะไรเมื่อคุณต้องการค้นหาปัญหา ? ตัวอย่าง 500 หรือ 5,000 รายการจะทำการวัดปัญหาด้วยความแม่นยำที่สูงขึ้น แต่จะไม่พบว่ามีความแม่นยำมากขึ้น
การนับคำสั่งหรือการเรียกใช้ฟังก์ชันมีประโยชน์
สมมติว่าคุณรู้ว่ามีการเรียกใช้ฟังก์ชัน 1,000 ครั้ง คุณช่วยบอกได้ไหมว่ามันมีค่าใช้จ่ายเท่าไหร่? คุณต้องทราบด้วยว่าต้องใช้เวลานานเท่าไหร่ในการรันโดยเฉลี่ยคูณด้วยการนับและหารด้วยเวลาทั้งหมด เวลาเฉลี่ยในการเรียกใช้อาจแตกต่างกันจากนาโนวินาทีเป็นวินาทีดังนั้นการนับเพียงอย่างเดียวจึงไม่ได้บอกอะไรมากมาย หากมีตัวอย่างสแต็กค่าใช้จ่ายของรูทีนหรือคำสั่งใด ๆ เป็นเพียงเศษส่วนของตัวอย่างที่เปิดอยู่ เศษส่วนของเวลานั้นเป็นสิ่งที่หลักการสามารถบันทึกได้โดยรวมถ้ากิจวัตรหรือข้อความไม่สามารถใช้เวลาได้ดังนั้นนั่นคือสิ่งที่มีความสัมพันธ์โดยตรงกับประสิทธิภาพการทำงานมากที่สุด
ไม่จำเป็นต้องทำการสุ่มตัวอย่างเมื่อถูกปิดกั้น
เหตุผลสำหรับตำนานนี้มีสองเท่า: 1) การสุ่มตัวอย่าง PC นั้นไม่มีความหมายเมื่อโปรแกรมกำลังรอและ 2) การลุ่มหลงกับความแม่นยำของเวลา อย่างไรก็ตามสำหรับ (1) โปรแกรมอาจรออะไรบางอย่างที่มันถามเช่นไฟล์ I / O ซึ่งคุณต้องรู้และตัวอย่างสแต็กเปิดเผย (เห็นได้ชัดว่าคุณต้องการยกเว้นตัวอย่างในขณะที่รอการป้อนข้อมูลจากผู้ใช้) สำหรับ (2) ถ้าโปรแกรมกำลังรอเพียงเพราะการแข่งขันกับกระบวนการอื่น ๆ นั่นอาจเกิดขึ้นแบบสุ่มค่อนข้างขณะที่มันกำลังทำงานอยู่ ดังนั้นในขณะที่โปรแกรมอาจใช้เวลานานขึ้นซึ่งจะไม่มีผลกระทบอย่างมากต่อสถิติที่สำคัญเปอร์เซ็นต์ของเวลาที่ข้อความอยู่บนสแต็ก
ว่า "เวลาของตัวเอง" สำคัญ
เวลาของตัวเองนั้นสมเหตุสมผลถ้าคุณวัดที่ระดับฟังก์ชั่นไม่ใช่ระดับของเส้นและคุณคิดว่าคุณต้องการความช่วยเหลือในการแยกแยะว่าเวลาของฟังก์ชั่นนั้นเข้าสู่การคำนวณในท้องถิ่น หากการสรุปที่ระดับบรรทัดบรรทัดจะแทนเวลาของตนเองหากอยู่ที่ท้ายสแต็กมิฉะนั้นจะแทนเวลาที่รวม ไม่ว่าจะด้วยวิธีใดสิ่งที่มีค่าใช้จ่ายคือเปอร์เซ็นต์ของตัวอย่างสแต็กที่เปิดอยู่เพื่อหาตำแหน่งของคุณในกรณีใดกรณีหนึ่ง
ตัวอย่างที่ต้องใช้ความถี่สูง
มาจากความคิดที่ว่าปัญหาประสิทธิภาพอาจจะออกฤทธิ์เร็วและตัวอย่างนั้นต้องถี่ๆเพื่อที่จะตีมัน แต่ถ้าปัญหามีค่าใช้จ่าย 20% พูดจากเวลาทำงานทั้งหมด 10 วินาที (หรืออะไรก็ตาม) แต่ละตัวอย่างในเวลารวมนั้นจะมีโอกาส 20% ที่จะชนมันไม่ว่าปัญหาจะเกิดขึ้นก็ตาม ในชิ้นเดียวเช่นนี้
.....XXXXXXXX...........................
.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^
(20 ตัวอย่าง, 4 เพลง)
หรือในหลาย ๆ ชิ้นเช่นนี้
X...X...X.X..X.........X.....X....X.....
.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^.^
(20 ตัวอย่าง, 3 เพลง)
ไม่ว่าจะด้วยวิธีใดจำนวนครั้งของการเข้าชมจะเฉลี่ยประมาณ 1 ใน 5 ไม่ว่าจะมีตัวอย่างกี่ตัวก็ตามหรือ กี่มากน้อย (ค่าเฉลี่ย = 20 * 0.2 = 4. ส่วนเบี่ยงเบนมาตรฐาน = +/- sqrt (20 * 0.2 * 0.8) = 1.8.)
ว่าคุณกำลังพยายามที่จะหาคอขวด
เช่นถ้ามีเพียงหนึ่ง พิจารณาระยะเวลาการดำเนินการดังต่อไปนี้ประกอบด้วยงานที่เป็นประโยชน์จริงแสดงโดยvxvWvzvWvxvWvYvWvxvWv.vWvxvWvYvW
.
มีปัญหาเกี่ยวกับประสิทธิภาพvWxYz
การทำงานของเวลา 1/2, 1/4, 1/8, 1/16, 1/32 ตามลำดับ การสุ่มตัวอย่างv
ทำได้ง่าย มันถูกลบออกจาก
xWzWxWYWxW.WxWYW
ตอนนี้โปรแกรมใช้เวลาครึ่งหนึ่งในการรันนานและตอนนี้W
ใช้เวลาครึ่งเวลา มันจะถูกลบออกจาก
xzxYx.xY
กระบวนการนี้ต่อไปทุกครั้งที่ลบที่ใหญ่ที่สุดโดยเปอร์เซ็นต์ปัญหาประสิทธิภาพจนกว่าจะพบอะไรที่จะลบ ตอนนี้สิ่งเดียวที่ถูกดำเนินการคือ.
ซึ่งดำเนินการใน 1/32 ของเวลาที่ใช้โดยโปรแกรมดั้งเดิม นี่คือเอฟเฟกต์การขยายซึ่งการลบปัญหาใด ๆ ทำให้ส่วนที่เหลือใหญ่ขึ้นโดยเปอร์เซ็นต์เนื่องจากตัวส่วนลดลง
ประเด็นสำคัญอีกประการหนึ่งคือต้องพบปัญหาทุกข้อ - ไม่มีข้อใดข้อ 5 ข้อใดที่ไม่พบปัญหา แค่ค้นหาบางอย่าง แต่ไม่ใช่ทั้งหมดไม่ใช่ "ดีพอ"
เพิ่ม: ฉันต้องการจะชี้ให้เห็นเหตุผลหนึ่งที่gprofได้รับความนิยม - กำลังได้รับการสอนสันนิษฐานว่าเป็นเพราะฟรีสอนง่ายและมันใช้เวลานานมาก การค้นหาโดย Google อย่างรวดเร็วตั้งอยู่ในสถาบันการศึกษาบางแห่งที่สอน (หรือดูเหมือนว่า):
เบิร์กลีย์ bu เคลมสันโคโลราโดดยุคเอิร์ลฮาม fsu อินเดียนา mit msu ncsa.illinois ncsu nyu ou พรินซ์ตัน psu สแตนฟอร์ด ucsd umd umich utah utah utexas utst wustl
** ยกเว้นวิธีอื่น ๆ ในการของานให้ทำซึ่งจะไม่ทิ้งร่องรอยไว้ว่าทำไมเช่นโดยการโพสต์ข้อความ
เนื่องจากฉันไม่เห็นอะไรที่นี่perf
ซึ่งเป็นเครื่องมือที่ค่อนข้างใหม่สำหรับการทำโปรไฟล์เคอร์เนลและแอปพลิเคชันผู้ใช้บน Linux ฉันตัดสินใจที่จะเพิ่มข้อมูลนี้
ก่อนอื่น - นี่คือการสอนเกี่ยวกับการทำโปรไฟล์ Linux ด้วยperf
คุณสามารถใช้perf
ถ้าเคอร์เนล Linux ของคุณมากกว่า 2.6.32 หรือoprofile
ถ้ามันเก่ากว่า ทั้งสองโปรแกรมไม่ต้องการให้คุณใช้โปรแกรมของคุณ (เช่นgprof
ต้องการ) อย่างไรก็ตามเพื่อให้ได้รับการโทรกราฟอย่างถูกต้องในคุณจำเป็นต้องสร้างคุณกับโปรแกรมperf
-fno-omit-frame-pointer
ตัวอย่างเช่นg++ -fno-omit-frame-pointer -O2 main.cpp
.
คุณสามารถดูการวิเคราะห์แอปพลิเคชันของคุณแบบ "สด" ด้วยperf top
:
sudo perf top -p `pidof a.out` -K
หรือคุณสามารถบันทึกข้อมูลประสิทธิภาพของแอปพลิเคชั่นที่รันอยู่และวิเคราะห์ได้หลังจากนั้น:
1) ในการบันทึกข้อมูลประสิทธิภาพ:
perf record -p `pidof a.out`
หรือบันทึกเป็นเวลา 10 วินาที:
perf record -p `pidof a.out` sleep 10
หรือบันทึกด้วยกราฟการโทร ()
perf record -g -p `pidof a.out`
2) เพื่อวิเคราะห์ข้อมูลที่บันทึกไว้
perf report --stdio
perf report --stdio --sort=dso -g none
perf report --stdio -g none
perf report --stdio -g
หรือคุณสามารถบันทึกข้อมูล performace ของแอปพลิเคชันและวิเคราะห์หลังจากนั้นเพียงแค่เปิดแอปพลิเคชันด้วยวิธีนี้และรอให้มันออกจากระบบ:
perf record ./a.out
นี่เป็นตัวอย่างของการทำโปรไฟล์โปรแกรมทดสอบ
โปรแกรมทดสอบอยู่ในไฟล์ main.cpp (ฉันจะใส่ main.cpp ที่ด้านล่างของข้อความ):
ฉันรวบรวมมันด้วยวิธีนี้:
g++ -m64 -fno-omit-frame-pointer -g main.cpp -L. -ltcmalloc_minimal -o my_test
ฉันใช้libmalloc_minimial.so
เพราะมันถูกคอมไพล์ด้วย-fno-omit-frame-pointer
ในขณะที่ libc malloc ดูเหมือนว่าจะรวบรวมโดยไม่มีตัวเลือกนี้ จากนั้นฉันก็รันโปรแกรมทดสอบ
./my_test 100000000
จากนั้นฉันบันทึกข้อมูลประสิทธิภาพของกระบวนการทำงาน:
perf record -g -p `pidof my_test` -o ./my_test.perf.data sleep 30
จากนั้นฉันวิเคราะห์โหลดต่อโมดูล:
รายงานที่สมบูรณ์แบบ --stdio -g none - ส่ง 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]
จากนั้นจะวิเคราะห์โหลดต่อฟังก์ชั่น:
รายงานที่สมบูรณ์แบบ --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 ...
จากนั้นจะวิเคราะห์เชนการเรียก:
รายงานที่สมบูรณ์แบบ --stdio -g กราฟ -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 ...
ดังนั้น ณ จุดนี้คุณรู้ว่าโปรแกรมของคุณใช้เวลาอย่างไร
และนี่คือ main.cpp สำหรับการทดสอบ:
#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;
}
f1
delete
40% (ประมาณ) ของเวลาที่process_request
โทรdelete
มา ส่วนที่เหลือเป็นส่วนที่new
ดี การวัดหยาบ แต่ฮอตสปอตถูกระบุ
As in my answer, you run it under a debugger and hit ^C at a random time and capture the stack trace
. 1) ฉันคิดว่าเทคนิคของคุณไม่มีประโยชน์เมื่อคุณต้องการวิเคราะห์ปัญหาด้านประสิทธิภาพสำหรับโปรแกรมที่ทำงานบนเซิร์ฟเวอร์ของลูกค้า 2) ฉันไม่แน่ใจว่าคุณใช้เทคนิคนี้อย่างไรในการรับข้อมูลสำหรับโปรแกรมที่มีเธรดจำนวนมากที่จัดการการร้องขอที่แตกต่างกัน ฉันหมายถึงเมื่อภาพทั่วไปค่อนข้างซับซ้อน
the problem is outside your code
ได้ไหม เนื่องจากคุณอาจต้องการข้อมูลบางอย่างเพื่อสนับสนุนประเด็นของคุณ ในบางสถานการณ์คุณอาจจำเป็นต้องทำโปรไฟล์ใบสมัครของคุณ คุณไม่สามารถขอให้ลูกค้าของคุณเริ่ม gdb แล้วกด ^ C และรับสายเรียกซ้อน นี่คือประเด็นของฉัน นี้เป็นตัวอย่างที่spielwiese.fontein.de/2012/01/22/... ฉันมีปัญหานี้และการทำโปรไฟล์ช่วยได้มาก
ลองoprofile มันเป็นเครื่องมือที่ดีกว่ามากสำหรับการทำโปรไฟล์รหัสของคุณ ฉันจะแนะนำ Intel VTuneด้วย
เครื่องมือทั้งสองด้านบนสามารถ จำกัด เวลาที่ใช้ในบรรทัดของรหัสที่ระบุคำอธิบายประกอบโค้ดของคุณแสดงชุดประกอบและใช้คำสั่งเฉพาะจำนวนเท่าใด นอกจากตัวชี้วัดเวลาแล้วคุณยังสามารถค้นหาตัวนับที่เฉพาะเจาะจงเช่นจำนวนครั้งที่แคชเป็นต้น
ไม่เหมือนกับ gprof คุณสามารถโพรไฟล์กระบวนการ / ไบนารีที่ทำงานบนระบบของคุณโดยใช้หนึ่งในสองวิธีนี้
เครื่องมือประสิทธิภาพของ Googleรวมถึงเครื่องมือสร้างโปรไฟล์ที่ใช้งานง่าย ซีพียูและตัวสร้างโปรไฟล์ฮีปพร้อมใช้งาน
http://lttng.org/หากคุณต้องการเครื่องมือติดตามประสิทธิภาพสูง