EnglishFrenchGermanItalianPortugueseRussianSpanish

ไอคอน Fav ของ OnWorks

mips-linux-gnu-gcov-5 - ออนไลน์ใน Cloud

เรียกใช้ mips-linux-gnu-gcov-5 ในผู้ให้บริการโฮสต์ฟรีของ OnWorks ผ่าน Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS

นี่คือคำสั่ง mips-linux-gnu-gcov-5 ที่สามารถเรียกใช้ในผู้ให้บริการโฮสต์ฟรีของ OnWorks โดยใช้หนึ่งในเวิร์กสเตชันออนไลน์ฟรีของเรา เช่น Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS

โครงการ:

ชื่อ


gcov - เครื่องมือทดสอบความครอบคลุม

เรื่องย่อ


จีโคฟ [-v|--รุ่น] [-h|--ช่วยด้วย]
[-a|--บล็อกทั้งหมด]
[-b|--สาขา-ความน่าจะเป็น]
[-c|--สาขานับ]
[-d|--display-ความคืบหน้า]
[-f|--ฟังก์ชั่น-สรุป]
[-i|--รูปแบบระดับกลาง]
[-l|--long-file-names]
[-m|--demangled-names]
[-n|--ไม่มีเอาต์พุต]
[-o|--วัตถุ-ไดเรกทอรี ไดเร็กทอรี|ไฟล์]
[-p|--รักษาเส้นทาง]
[-r|--ญาติ-เท่านั้น]
[-s|--แหล่งที่มา-คำนำหน้า ไดเรกทอรี]
[-u|--ไม่มีเงื่อนไข-สาขา]
ไฟล์

DESCRIPTION


gcov เป็นโปรแกรมครอบคลุมการทดสอบ ใช้ร่วมกับ GCC เพื่อวิเคราะห์โปรแกรมของคุณไปยัง
ช่วยสร้างโค้ดที่มีประสิทธิภาพและทำงานเร็วขึ้น และค้นหาส่วนที่ยังไม่ทดสอบของคุณ
โปรแกรม. คุณสามารถใช้ได้ gcov เป็นเครื่องมือสร้างโปรไฟล์เพื่อช่วยค้นหาว่าการเพิ่มประสิทธิภาพของคุณอยู่ที่ไหน
ความพยายามจะส่งผลดีที่สุดต่อโค้ดของคุณ คุณสามารถใช้ gcov พร้อมกับโปรไฟล์อื่น ๆ
เครื่องมือ, gprofเพื่อประเมินว่าโค้ดส่วนใดของคุณใช้เวลาประมวลผลมากที่สุด

เครื่องมือสร้างโปรไฟล์ช่วยให้คุณวิเคราะห์ประสิทธิภาพของโค้ดได้ การใช้ตัวสร้างโปรไฟล์เช่น gcov
or gprofคุณสามารถดูสถิติประสิทธิภาพพื้นฐานบางอย่างได้ เช่น:

* ความถี่ในการรันโค้ดแต่ละบรรทัด

* โค้ดใดที่รันได้จริง

* ระยะเวลาในการคำนวณที่แต่ละส่วนของโค้ดใช้

เมื่อคุณทราบสิ่งเหล่านี้เกี่ยวกับวิธีการทำงานของโค้ดของคุณเมื่อคอมไพล์แล้ว คุณสามารถดูแต่ละรายการได้
โมดูลเพื่อดูว่าโมดูลใดควรได้รับการปรับให้เหมาะสม gcov ช่วยให้คุณกำหนดสถานที่ทำงาน
เกี่ยวกับการเพิ่มประสิทธิภาพ

นักพัฒนาซอฟต์แวร์ยังใช้การทดสอบความครอบคลุมร่วมกับชุดทดสอบเพื่อให้แน่ใจว่า
ซอฟต์แวร์นั้นดีพอสำหรับการเปิดตัวจริงๆ Testsuites สามารถตรวจสอบว่าโปรแกรม
ทำงานตามที่คาดไว้ โปรแกรมความครอบคลุมจะทดสอบเพื่อดูว่าโปรแกรมนั้นออกกำลังกายมากแค่ไหน
ห้องทดลอง นักพัฒนาสามารถกำหนดได้ว่าต้องเพิ่มกรณีทดสอบประเภทใดบ้าง
ชุดทดสอบเพื่อสร้างทั้งการทดสอบที่ดีขึ้นและผลิตภัณฑ์ขั้นสุดท้ายที่ดีขึ้น

คุณควรคอมไพล์โค้ดของคุณโดยไม่ต้องปรับให้เหมาะสมหากคุณวางแผนที่จะใช้ gcov เพราะ
การเพิ่มประสิทธิภาพโดยการรวมโค้ดบางบรรทัดเป็นฟังก์ชันเดียว อาจไม่ทำให้คุณได้มากเท่า
ข้อมูลตามที่คุณต้องการเพื่อค้นหา 'ฮอตสปอต' ที่โค้ดใช้จำนวนมาก
เวลาคอมพิวเตอร์ เช่นเดียวกันเพราะ gcov รวบรวมสถิติตามบรรทัด (ที่ต่ำสุด
ความละเอียด) จะทำงานได้ดีที่สุดกับรูปแบบการเขียนโปรแกรมที่ใส่คำสั่งเดียวในแต่ละอัน
ไลน์. หากคุณใช้มาโครที่ซับซ้อนซึ่งขยายเป็นลูปหรือไปยังโครงสร้างการควบคุมอื่นๆ
สถิติมีประโยชน์น้อยกว่า---รายงานเฉพาะในบรรทัดที่แมโครเรียก
ปรากฏขึ้น หากมาโครที่ซับซ้อนของคุณทำงานเหมือนฟังก์ชัน คุณสามารถแทนที่พวกมันด้วย inline
ทำหน้าที่แก้ปัญหานี้

gcov สร้างไฟล์บันทึกที่เรียกว่า sourcefile.gcov ซึ่งระบุจำนวนครั้งที่แต่ละบรรทัดของ
ไฟล์ต้นฉบับ sourcefile.c ได้ดำเนินการ คุณสามารถใช้ไฟล์บันทึกเหล่านี้ร่วมกับ gprof ไปยัง
ช่วยในการปรับแต่งประสิทธิภาพของโปรแกรมของคุณ gprof ให้ข้อมูลเวลาคุณ
สามารถใช้ควบคู่กับข้อมูลที่คุณได้รับจาก gcov.

gcov ใช้งานได้กับโค้ดที่คอมไพล์ด้วย GCC เท่านั้น เข้ากันไม่ได้กับโปรไฟล์อื่น ๆ
หรือกลไกการทดสอบความครอบคลุม

OPTIONS


-h
--ช่วยด้วย
แสดงความช่วยเหลือเกี่ยวกับการใช้ gcov (บนเอาต์พุตมาตรฐาน) และออกโดยไม่ทำอะไรเลย
การประมวลผลเพิ่มเติม

-v
--รุ่น
แสดง gcov หมายเลขเวอร์ชัน (บนเอาต์พุตมาตรฐาน) และออกโดยไม่ทำอะไรเลย
การประมวลผลเพิ่มเติม

-a
--บล็อกทั้งหมด
เขียนการดำเนินการแต่ละรายการนับสำหรับบล็อกพื้นฐานทุกอัน ปกติ gcov outputs
การดำเนินการจะนับเฉพาะบล็อกหลักของบรรทัด ด้วยตัวเลือกนี้ คุณสามารถ
ตรวจสอบว่าไม่มีการดำเนินการบล็อกภายในบรรทัดเดียวหรือไม่

-b
--สาขา-ความน่าจะเป็น
เขียนความถี่ของสาขาไปที่ไฟล์เอาต์พุต และเขียนข้อมูลสรุปสาขาไปที่
เอาต์พุตมาตรฐาน ตัวเลือกนี้ช่วยให้คุณเห็นความถี่ของแต่ละสาขาในโปรแกรมของคุณ
ถูกนำไป. สาขาที่ไม่มีเงื่อนไขจะไม่แสดง เว้นแต่ -u มีตัวเลือกให้

-c
--สาขานับ
เขียนความถี่ของสาขาเป็นจำนวนสาขาที่รับ แทนที่จะเป็นเปอร์เซ็นต์
ของสาขาที่รับ

-n
--ไม่มีเอาต์พุต
อย่าสร้าง gcov ไฟล์ที่ส่งออก

-l
--long-file-names
สร้างชื่อไฟล์แบบยาวสำหรับไฟล์ต้นฉบับที่รวมอยู่ ตัวอย่างเช่น ถ้าไฟล์ส่วนหัว xh
มีรหัสและรวมอยู่ในไฟล์ acแล้ววิ่ง gcov ในไฟล์ ac
จะสร้างไฟล์เอาต์พุตชื่อ ac##xhgcov แทน xhgcov. สิ่งนี้สามารถ
มีประโยชน์ถ้า xh รวมอยู่ในไฟล์ต้นฉบับหลายไฟล์และคุณต้องการเห็นแต่ละไฟล์
ผลงาน หากคุณใช้ -p ตัวเลือกทั้งชื่อไฟล์รวมและรวม
จะเป็นชื่อพาธที่สมบูรณ์

-p
--รักษาเส้นทาง
รักษาข้อมูลเส้นทางที่สมบูรณ์ในชื่อที่สร้างขึ้น .gcov ไฟล์. ปราศจาก
ตัวเลือกนี้ใช้เฉพาะองค์ประกอบชื่อไฟล์ ด้วยตัวเลือกนี้ ไดเรกทอรีทั้งหมด
ใช้กับ / ตัวอักษรที่แปลเป็นภาษา # ตัวอักษร . ส่วนประกอบไดเร็กทอรีถูกลบออก
และถอดไม่ได้ .. ส่วนประกอบเปลี่ยนชื่อเป็น ^. สิ่งนี้มีประโยชน์หากไฟล์ต้นฉบับอยู่ใน
ไดเร็กทอรีต่างๆ

-r
--ญาติ-เท่านั้น
ส่งออกเฉพาะข้อมูลเกี่ยวกับซอร์สไฟล์ที่มีชื่อพาธสัมพันธ์ (หลัง source
การกำจัดคำนำหน้า) เส้นทางสัมบูรณ์มักจะเป็นไฟล์ส่วนหัวของระบบและความครอบคลุมของทุก
ฟังก์ชันอินไลน์ในนั้นมักจะไม่น่าสนใจ

-f
--ฟังก์ชั่น-สรุป
สรุปผลลัพธ์สำหรับแต่ละฟังก์ชันนอกเหนือจากสรุประดับไฟล์

-o ไดเร็กทอรี|ไฟล์
--วัตถุ-ไดเรกทอรี ไดเรกทอรี
--object-file ไฟล์
ระบุไดเร็กทอรีที่มีไฟล์ข้อมูล gcov หรือชื่อพาธอ็อบเจ็กต์
พื้นที่ปลูก .gcnoและ .gcda ค้นหาไฟล์ข้อมูลโดยใช้ตัวเลือกนี้ ถ้าไดเร็กทอรีเป็น
ที่ระบุ ไฟล์ข้อมูลอยู่ในไดเร็กทอรีนั้นและตั้งชื่อตามชื่อไฟล์อินพุต
โดยไม่ต้องขยาย หากระบุไฟล์ไว้ที่นี่ ไฟล์ข้อมูลจะถูกตั้งชื่อตาม
ไฟล์นั้นโดยไม่มีนามสกุล

-s ไดเรกทอรี
--แหล่งที่มา-คำนำหน้า ไดเรกทอรี
คำนำหน้าสำหรับชื่อไฟล์ต้นทางที่จะลบออกเมื่อสร้างไฟล์ครอบคลุมเอาต์พุต
ตัวเลือกนี้มีประโยชน์เมื่อสร้างในไดเร็กทอรีแยกต่างหาก และชื่อพาธไปยัง
ไม่ต้องการไดเร็กทอรีต้นทางเมื่อกำหนดชื่อไฟล์เอาต์พุต โปรดทราบว่าสิ่งนี้
มีการใช้การตรวจหาคำนำหน้าก่อนที่จะพิจารณาว่าไฟล์ต้นฉบับเป็นแบบสัมบูรณ์หรือไม่

-u
--ไม่มีเงื่อนไข-สาขา
เมื่อมีความน่าจะเป็นของสาขา ให้รวมสาขาที่ไม่มีเงื่อนไขด้วย
กิ่งที่ไม่มีเงื่อนไขมักจะไม่น่าสนใจ

-d
--display-ความคืบหน้า
แสดงความคืบหน้าของเอาต์พุตมาตรฐาน

-i
--รูปแบบระดับกลาง
เอาต์พุตไฟล์ gcov ในรูปแบบข้อความกลางที่ง่ายต่อการแยกวิเคราะห์ซึ่งสามารถใช้ได้โดย lcov
หรือเครื่องมืออื่นๆ ผลลัพธ์เป็นหนึ่งเดียว .gcov ไฟล์ต่อ .gcda ไฟล์. ไม่มีซอร์สโค้ดคือ
จำเป็นต้องใช้

รูปแบบของสื่อกลาง .gcov ไฟล์เป็นข้อความธรรมดาที่มีหนึ่งรายการต่อบรรทัด

ไฟล์:
การทำงาน: , ,
ฉันนับ: ,
สาขา: ,

ที่ไหน เป็น
notexec (ไม่ได้ดำเนินการสาขา)
นำ (สาขาดำเนินการและดำเนินการ)
nottaken (สาขาดำเนินการแต่ไม่ได้ดำเนินการ)

สามารถมีได้หลายแบบ รายการใน gcov ระดับกลาง
ไฟล์. รายการทั้งหมดที่ติดตาม a เกี่ยวข้องกับไฟล์ต้นฉบับนั้น
จนถึงตอนต่อไป รายการ.

นี่คือตัวอย่างเมื่อ -i ใช้ร่วมกับ -b ตัวเลือก:

ไฟล์:array.cc
ฟังก์ชัน:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
ฟังก์ชัน:22,1,หลัก
ลนับ:11,1
ลนับ:12,1
ลนับ:14,1
สาขา:14,ถ่ายแล้ว
ลนับ:26,1
สาขา:28,nottaken

-m
--demangled-names
แสดงชื่อฟังก์ชันที่แยกส่วนในเอาต์พุต ค่าเริ่มต้นคือการแสดงฟังก์ชัน mangled
ชื่อ

gcov ควรรันด้วยไดเร็กทอรีปัจจุบันเหมือนกับที่คุณเรียกใช้
คอมไพเลอร์ มิฉะนั้นจะไม่สามารถค้นหาไฟล์ต้นทางได้ gcov สร้างไฟล์
ที่เรียกว่า mangledname.gcov ในไดเร็กทอรีปัจจุบัน ประกอบด้วยข้อมูลความคุ้มครอง
ของไฟล์ต้นฉบับที่พวกเขาเกี่ยวข้อง หนึ่ง .gcov ไฟล์ถูกสร้างขึ้นสำหรับแต่ละแหล่ง (หรือ
header) ไฟล์ที่มีโค้ดซึ่งถูกคอมไพล์เพื่อสร้างไฟล์ข้อมูล NS
mangledname ส่วนหนึ่งของชื่อไฟล์ที่ส่งออกมักจะเป็นเพียงชื่อไฟล์ต้นทาง แต่สามารถ
จะเป็นสิ่งที่ซับซ้อนมากขึ้นหาก -l or -p มีตัวเลือกให้ อ้างถึงตัวเลือกเหล่านั้น
เพื่อดูรายละเอียด

หากคุณเรียกใช้ gcov ด้วยไฟล์อินพุตหลายไฟล์ ผลงานจากไฟล์อินพุตแต่ละไฟล์คือ
สรุป โดยปกติคุณจะเรียกใช้ด้วยรายการไฟล์เดียวกันกับลิงก์สุดท้ายของ
ไฟล์ปฏิบัติการของคุณ

พื้นที่ปลูก .gcov ไฟล์มี : แยกฟิลด์พร้อมกับซอร์สโค้ดของโปรแกรม รูปแบบ
is

: :

ข้อมูลบล็อกเพิ่มเติมอาจสำเร็จในแต่ละบรรทัด เมื่อมีการร้องขอโดยตัวเลือกบรรทัดคำสั่ง
พื้นที่ปลูก การดำเนินการ_count is - สำหรับบรรทัดที่ไม่มีรหัส เส้นที่ไม่ได้ดำเนินการจะถูกทำเครื่องหมาย #####
or ====ขึ้นอยู่ว่าจะเข้าถึงได้โดยเส้นทางที่ไม่พิเศษหรือเท่านั้น
เส้นทางพิเศษ เช่น ตัวจัดการข้อยกเว้น C++ ตามลำดับ

ข้อมูลบางบรรทัดที่จุดเริ่มต้นมี line_number ของศูนย์ คำนำเหล่านี้คือ
ของแบบฟอร์ม

-:0: :

ลำดับและจำนวนบทนำเหล่านี้จะเพิ่มเป็น gcov พัฒนาการ
ดำเนินไป --- อย่าพึ่งให้คงอยู่ไม่เปลี่ยนแปลง ใช้ แท็ก เพื่อค้นหาเฉพาะ
คำนำ.

ข้อมูลบล็อกเพิ่มเติมอยู่ในรูปแบบ



พื้นที่ปลูก ข้อมูล มนุษย์สามารถอ่านได้ แต่ออกแบบให้เรียบง่ายเพียงพอสำหรับการแยกวิเคราะห์ด้วยเครื่อง
เกินไป

เมื่อพิมพ์เปอร์เซ็นต์ 0% และ 100% จะถูกพิมพ์เฉพาะเมื่อค่าเป็น เผง 0% และ
100% ตามลำดับ ค่าอื่นๆ ที่จะปัดเศษตามอัตภาพเป็น 0% หรือ 100% คือ
แทนพิมพ์เป็นค่านอกขอบเขตที่ใกล้ที่สุดแทน

เมื่อใช้ gcovก่อนอื่น คุณต้องคอมไพล์โปรแกรมด้วยตัวเลือก GCC พิเศษสองตัวเลือก:
-fprofile-arcs -ftest-ครอบคลุม. สิ่งนี้บอกให้คอมไพเลอร์สร้างเพิ่มเติม
ข้อมูลที่จำเป็นโดย gcov (โดยทั่วไปเป็นโฟลว์กราฟของโปรแกรม) และยังรวมถึง
รหัสเพิ่มเติมในไฟล์อ็อบเจ็กต์สำหรับสร้างข้อมูลโปรไฟล์เพิ่มเติมที่จำเป็น
โดย gcov. ไฟล์เพิ่มเติมเหล่านี้จะถูกวางไว้ในไดเร็กทอรีที่ไฟล์อ็อบเจ็กต์คือ
ที่ตั้งอยู่

การรันโปรแกรมจะทำให้สร้างเอาต์พุตโปรไฟล์ สำหรับแต่ละไฟล์ต้นฉบับ
เรียบเรียงด้วย -fprofile-arcsประกอบ .gcda ไฟล์จะถูกวางไว้ในไฟล์วัตถุ
ไดเรกทอรี

เล่น gcov ด้วยชื่อไฟล์ต้นฉบับของโปรแกรมของคุณเนื่องจากอาร์กิวเมนต์จะสร้างรายการ
ของรหัสพร้อมกับความถี่ในการดำเนินการสำหรับแต่ละบรรทัด ตัวอย่างเช่น ถ้าโปรแกรมของคุณ
ถูกเรียก tmp.cนี่คือสิ่งที่คุณจะเห็นเมื่อคุณใช้พื้นฐาน gcov สิ่งอำนวยความสะดวก:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$ a.out
$ gcov tmp.c
90.00% ของ 10 ซอร์สไลน์ดำเนินการในไฟล์ tmp.c
กำลังสร้าง tmp.c.gcov

ไฟล์ tmp.c.gcov มีเอาต์พุตจาก gcov. นี่คือตัวอย่าง:

-: 0:ที่มา:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:วิ่ง:1
-: 0:โปรแกรม:1
-: 1:#รวม
-: 2:
-: 3:int หลัก (เป็นโมฆะ)
1: 4:{
1: 5: int i ทั้งหมด;
-: 6:
1: 7: ทั้งหมด = 0;
-: 8:
11: 9: สำหรับ (i = 0; i < 10; i++)
10: 10: รวม += ผม;
-: 11:
1: 12: ถ้า (ทั้งหมด != 45)
#####: 13: printf ("ความล้มเหลว\n");
-: 14: อื่น
1: 15: printf ("สำเร็จ\n");
1: 16: คืนค่า 0;
-: 17:}

เมื่อคุณใช้ -a ตัวเลือก คุณจะได้รับจำนวนบล็อกแต่ละบล็อก และผลลัพธ์จะดู
อย่างนี้:

-: 0:ที่มา:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:วิ่ง:1
-: 0:โปรแกรม:1
-: 1:#รวม
-: 2:
-: 3:int หลัก (เป็นโมฆะ)
1: 4:{
1: 4-block 0
1: 5: int i ทั้งหมด;
-: 6:
1: 7: ทั้งหมด = 0;
-: 8:
11: 9: สำหรับ (i = 0; i < 10; i++)
11: 9-block 0
10: 10: รวม += ผม;
10: 10-block 0
-: 11:
1: 12: ถ้า (ทั้งหมด != 45)
1: 12-block 0
#####: 13: printf ("ความล้มเหลว\n");
$$$$$: 13-บล็อก 0
-: 14: อื่น
1: 15: printf ("สำเร็จ\n");
1: 15-block 0
1: 16: คืนค่า 0;
1: 16-block 0
-: 17:}

ในโหมดนี้ แต่ละบล็อกพื้นฐานจะแสดงเพียงบรรทัดเดียว -- บรรทัดสุดท้ายของบล็อก NS
บล็อกหลายบรรทัดจะสนับสนุนเฉพาะการนับการดำเนินการของบรรทัดสุดท้ายนั้นและอื่น ๆ
บรรทัดจะไม่ปรากฏว่ามีรหัส เว้นแต่บล็อกก่อนหน้าจะสิ้นสุดที่บรรทัดเหล่านั้น NS
แสดงจำนวนการดำเนินการทั้งหมดของบรรทัดและบรรทัดถัดไปแสดงจำนวนการดำเนินการ
สำหรับแต่ละบล็อคที่สิ้นสุดในบรรทัดนั้น หลังจากแต่ละบล็อก จำนวนสาขาและการโทรจะถูกนับ
ของบล็อกจะแสดงถ้า -b มีตัวเลือกให้

เนื่องจากวิธีการโทรของเครื่องมือ GCC จำนวนการโทรสามารถแสดงได้หลังบรรทัดที่ไม่มี
แต่ละบล็อก อย่างที่คุณเห็น บรรทัดที่ 13 มีบล็อกพื้นฐานที่ไม่ได้ดำเนินการ

เมื่อคุณใช้ -b ตัวเลือกผลลัพธ์ของคุณมีลักษณะดังนี้:

$ gcov -b tmp.c
90.00% ของ 10 ซอร์สไลน์ดำเนินการในไฟล์ tmp.c
80.00% ของ 5 สาขาดำเนินการในไฟล์ tmp.c
80.00% ของ 5 สาขาอย่างน้อยหนึ่งครั้งในไฟล์ tmp.c
50.00% ของการโทร 2 ครั้งในไฟล์ tmp.c
กำลังสร้าง tmp.c.gcov

นี่คือตัวอย่างผลลัพธ์ tmp.c.gcov ไฟล์:

-: 0:ที่มา:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:วิ่ง:1
-: 0:โปรแกรม:1
-: 1:#รวม
-: 2:
-: 3:int หลัก (เป็นโมฆะ)
ฟังก์ชั่นหลักที่เรียกว่า 1 ส่งคืน 1 บล็อกดำเนินการ 75%
1: 4:{
1: 5: int i ทั้งหมด;
-: 6:
1: 7: ทั้งหมด = 0;
-: 8:
11: 9: สำหรับ (i = 0; i < 10; i++)
สาขา 0 รับ 91% (ลดลง)
สาขา 1 รับ 9%
10: 10: รวม += ผม;
-: 11:
1: 12: ถ้า (ทั้งหมด != 45)
สาขา 0 รับ 0% (ลดลง)
สาขา 1 รับ 100%
#####: 13: printf ("ความล้มเหลว\n");
โทร 0 ไม่เคยดำเนินการ
-: 14: อื่น
1: 15: printf ("สำเร็จ\n");
โทร 0 โทร 1 คืน 100%
1: 16: คืนค่า 0;
-: 17:}

สำหรับแต่ละฟังก์ชัน จะมีการพิมพ์บรรทัดแสดงจำนวนครั้งที่เรียกใช้ฟังก์ชัน ว่า
ส่งคืนหลายครั้งและเปอร์เซ็นต์ของบล็อกของฟังก์ชันถูกดำเนินการ

สำหรับแต่ละบล็อกพื้นฐาน บรรทัดจะถูกพิมพ์หลังจากบรรทัดสุดท้ายของบล็อกพื้นฐานที่อธิบาย
สาขาหรือสายที่สิ้นสุดบล็อกพื้นฐาน มีหลายสาขาและโทรได้
แสดงรายการสำหรับบรรทัดต้นทางเดียวหากมีบล็อกพื้นฐานหลายบล็อกที่สิ้นสุดในบรรทัดนั้น
ในกรณีนี้แต่ละสาขาและการโทรจะได้รับหมายเลข ไม่มีวิธีง่ายๆในการ
แมปสาขาเหล่านี้และเรียกกลับไปที่โครงสร้างต้นทาง โดยทั่วไปแล้ว ค่าต่ำสุด
สาขาที่มีหมายเลขหรือการโทรจะสอดคล้องกับโครงสร้างด้านซ้ายสุดบนบรรทัดต้นทาง

สำหรับสาขา หากดำเนินการอย่างน้อยหนึ่งครั้ง เปอร์เซ็นต์ที่ระบุจำนวน
ครั้งที่สาขาถูกนำออกไปหารด้วยจำนวนครั้งที่สาขาถูกดำเนินการจะเป็น
พิมพ์ มิฉะนั้น ข้อความ "ไม่เคยดำเนินการ" จะถูกพิมพ์

สำหรับการโทรหากมีการดำเนินการอย่างน้อยหนึ่งครั้ง เปอร์เซ็นต์ที่ระบุจำนวน
จำนวนครั้งที่โทรกลับหารด้วยจำนวนครั้งที่โทรออกจะเป็น
พิมพ์ โดยปกติจะเป็น 100% แต่อาจน้อยกว่าสำหรับฟังก์ชันที่เรียกว่า "exit" หรือ
"longjmp" ดังนั้นจึงอาจไม่กลับมาทุกครั้งที่ถูกเรียก

จำนวนการดำเนินการเป็นแบบสะสม หากโปรแกรมตัวอย่างถูกดำเนินการอีกครั้งโดยไม่มี
การลบไฟล์ .gcda ไฟล์ จำนวนครั้งในแต่ละบรรทัดในแหล่งที่มาคือ
การดำเนินการจะถูกเพิ่มเข้ากับผลลัพธ์ของการรันครั้งก่อน สิ่งนี้อาจมีประโยชน์
ได้หลายวิธี ตัวอย่างเช่น สามารถใช้เพื่อรวบรวมข้อมูลจำนวน
โปรแกรมทำงานเป็นส่วนหนึ่งของชุดการตรวจสอบการทดสอบ หรือเพื่อให้มีความแม่นยำมากขึ้นในระยะยาว
ข้อมูลการรันโปรแกรมจำนวนมาก

ข้อมูลใน .gcda ไฟล์จะถูกบันทึกทันทีก่อนที่โปรแกรมจะออก แต่ละ
ไฟล์ต้นฉบับที่คอมไพล์ด้วย -fprofile-arcs, รหัสโปรไฟล์พยายามอ่านครั้งแรกใน an
ที่มีอยู่ .gcda ไฟล์; หากไฟล์ไม่ตรงกับไฟล์เรียกทำงาน (จำนวนที่แตกต่างกันของ basic
จำนวนบล็อก) จะไม่สนใจเนื้อหาของไฟล์ จากนั้นจะเพิ่มในการดำเนินการใหม่
นับและสุดท้ายเขียนข้อมูลลงในไฟล์

การใช้ gcov กับ GCC การเพิ่มประสิทธิภาพ

หากคุณวางแผนที่จะใช้ gcov เพื่อช่วยเพิ่มประสิทธิภาพโค้ดของคุณ ก่อนอื่นคุณต้องคอมไพล์โปรแกรมของคุณ
ด้วยสองตัวเลือก GCC พิเศษ: -fprofile-arcs -ftest-ครอบคลุม. นอกจากนั้น คุณสามารถ
ใช้ตัวเลือก GCC อื่น ๆ แต่ถ้าคุณต้องการพิสูจน์ว่าทุกบรรทัดในโปรแกรมของคุณ
ถูกดำเนินการ คุณไม่ควรคอมไพล์ด้วยการปรับให้เหมาะสมในเวลาเดียวกัน ในบางเครื่อง
เครื่องมือเพิ่มประสิทธิภาพสามารถกำจัดบรรทัดโค้ดง่ายๆ บางส่วนได้โดยการรวมบรรทัดเหล่านี้กับบรรทัดอื่นๆ
ตัวอย่างเช่นรหัสเช่นนี้:

ถ้า (a != b)
ค = 1;
อื่น
ค = 0;

สามารถคอมไพล์เป็นคำสั่งเดียวได้ในบางเครื่อง ในกรณีนี้ไม่มีทางที่จะ
gcov เพื่อคำนวณจำนวนการดำเนินการแยกกันสำหรับแต่ละบรรทัดเพราะไม่มีการแยก
รหัสสำหรับแต่ละบรรทัด ดังนั้น gcov ผลลัพธ์จะออกมาเป็นแบบนี้ถ้าคุณคอมไพล์โปรแกรม
ด้วยการเพิ่มประสิทธิภาพ:

100:12:if (a != b)
100: 13: ค = 1;
100: 14:อื่น
100: 15: ค = 0;

ผลลัพธ์แสดงให้เห็นว่ากลุ่มของรหัสนี้ รวมกันโดยการเพิ่มประสิทธิภาพ ดำเนินการ 100 ครั้ง
ในแง่หนึ่งผลลัพธ์นี้ถูกต้อง เพราะมีเพียงหนึ่งคำสั่งแทน
ทั้งสี่บรรทัดนี้ อย่างไรก็ตาม ผลลัพธ์ไม่ได้ระบุจำนวนครั้งของผลลัพธ์
เท่ากับ 0 และผลลัพธ์ที่ได้คือ 1 กี่ครั้ง

ฟังก์ชันแบบอินไลน์ได้สามารถสร้างจำนวนบรรทัดที่ไม่คาดคิดได้ จำนวนบรรทัดจะแสดงสำหรับ
ซอร์สโค้ดของฟังก์ชัน inlineable แต่สิ่งที่แสดงขึ้นอยู่กับว่าฟังก์ชันอยู่ที่ไหน
inline หรือถ้าไม่มี inline เลย

ถ้าฟังก์ชันไม่อยู่ในบรรทัด คอมไพเลอร์ต้องปล่อยสำเนาของ
ฟังก์ชั่นในไฟล์อ็อบเจ็กต์ใด ๆ ที่ต้องการ ถ้า ไฟล์A.o และ fileB.o ทั้งสองมีออกจาก
เนื้อหาเส้นของฟังก์ชันอินไลน์ได้เฉพาะ พวกเขาทั้งคู่ก็จะมีการครอบคลุมด้วย
นับสำหรับฟังก์ชันนั้น เมื่อไหร่ ไฟล์A.o และ fileB.o เชื่อมโยงเข้าด้วยกัน ตัวเชื่อมโยงจะ
ในหลายระบบ เลือกหนึ่งในเนื้อหาที่ไม่อยู่ในบรรทัดสำหรับการเรียกใช้ฟังก์ชันนั้นทั้งหมด
และลบหรือเพิกเฉยต่ออีกฝ่ายหนึ่ง เสียดายไม่ได้ถอดเคาน์เตอร์ครอบคลุม
สำหรับฟังก์ชั่นที่ไม่ได้ใช้งาน ดังนั้นเมื่อใช้เครื่องมือ ทั้งหมดยกเว้นการใช้ฟังก์ชันนั้น
จะแสดงการนับเป็นศูนย์

หากฟังก์ชันอยู่ในหลายตำแหน่ง โครงสร้างบล็อกในแต่ละตำแหน่งอาจ
ไม่เหมือนกัน ตัวอย่างเช่น เงื่อนไขสามารถคำนวณได้ในเวลาคอมไพล์ใน
บางกรณี เพราะจะแสดงความครอบคลุมของการใช้งานฟังก์ชันอินไลน์ทั้งหมด
สำหรับบรรทัดต้นทางเดียวกัน บรรทัดที่นับเองอาจดูเหมือนไม่สอดคล้องกัน

แอปพลิเคชันที่ใช้เวลานานสามารถใช้สิ่งอำนวยความสะดวก "_gcov_reset" และ "_gcov_dump" เพื่อ
จำกัดการรวบรวมโปรไฟล์เฉพาะภูมิภาคของโปรแกรมที่สนใจ กำลังเรียก "_gcov_reset(เป็นโมฆะ)"
จะล้างตัวนับโปรไฟล์ทั้งหมดเป็นศูนย์ และการเรียก "_gcov_dump(void)" จะทำให้
ข้อมูลโปรไฟล์ที่รวบรวม ณ จุดนั้นจะถูกทิ้งไปยัง .gcda ไฟล์ที่ส่งออก

ใช้ mips-linux-gnu-gcov-5 ออนไลน์โดยใช้บริการ onworks.net


Ad


Ad

โปรแกรมออนไลน์ Linux และ Windows ล่าสุด