alpha-linux-gnu-gcov - מקוון בענן

תָכְנִית:

שֵׁם

gcov - כלי לבדיקת כיסוי

תַקצִיר

gcov [-v|--גִרְסָה] [-h|- עזרה]
[-a|-- כל הבלוקים]
[-b|--סניף-הסתברויות]
[-c|--סניפי-ספירות]
[-d|--תצוגה-התקדמות]
[-f|--סיכומי פונקציות]
[-i|--פורמט בינוני]
[-l|-- שמות קבצים ארוכים]
[-m|--שמות מעורפלים]
[-n|--אין פלט]
[-o|---object-directory ספרייה|קובץ]
[-p|--שימור-נתיבים]
[-r|--יחסי בלבד]
[-s|--תחילית מקור בספרייה]
[-u|--ענפים ללא תנאי]
קבצים

תיאור

gcov היא תוכנית סיקור מבחן. השתמש בו בשיתוף עם GCC כדי לנתח את התוכניות שלך
לעזור ליצור קוד ריצה יעיל ומהיר יותר ולגלות חלקים שלא נבדקו שלך
תכנית. אתה יכול להשתמש gcov ככלי ליצירת פרופיל כדי לעזור לגלות היכן האופטימיזציה שלך
המאמצים ישפיעו בצורה הטובה ביותר על הקוד שלך. אתה יכול גם להשתמש gcov יחד עם הפרופיל השני
כלי, gprof, כדי להעריך אילו חלקים בקוד שלך משתמשים בכמות הגדולה ביותר של זמן מחשוב.

כלי יצירת פרופיל עוזרים לך לנתח את ביצועי הקוד שלך. שימוש בפרופילים כגון gcov
or gprof, תוכל לגלות כמה סטטיסטיקות ביצועים בסיסיות, כגון:

* באיזו תדירות כל שורת קוד מופעלת

* אילו שורות קוד מבוצעות בפועל

* כמה זמן מחשוב כל חלק של קוד משתמש

ברגע שאתה יודע את הדברים האלה על איך הקוד שלך עובד כשהוא מורכב, אתה יכול להסתכל על כל אחד מהם
מודול כדי לראות אילו מודולים יש לבצע אופטימיזציה. gcov עוזר לך לקבוע היכן לעבוד
על אופטימיזציה.

מפתחי תוכנה משתמשים גם בבדיקות כיסוי בשילוב עם חבילות בדיקות, כדי לוודא
התוכנה היא למעשה מספיק טובה לשחרור. Testsuites יכול לאמת שתוכנית
עובד כצפוי; תוכנית כיסוי בוחנת כדי לראות כמה מהתוכנית מופעל על ידי
חבילת הבדיקות. מפתחים יכולים לאחר מכן לקבוע לאילו סוגי מקרי בדיקה יש להוסיף
חבילות הבדיקה כדי ליצור גם בדיקות טובות יותר וגם מוצר סופי טוב יותר.

עליך להרכיב את הקוד שלך ללא אופטימיזציה אם אתה מתכנן להשתמש gcov בגלל
אופטימיזציה, על ידי שילוב של כמה שורות קוד לפונקציה אחת, עשויה שלא לתת לך כל כך הרבה
מידע כפי שאתה צריך כדי לחפש 'נקודות חמות' שבהן הקוד משתמש בהרבה
זמן מחשב. כמו כן, כי gcov צובר נתונים סטטיסטיים לפי שורה (לכל הפחות
רזולוציה), זה עובד הכי טוב עם סגנון תכנות שמציב רק הצהרה אחת על כל אחד
קַו. אם אתה משתמש בפקודות מאקרו מסובכות שמתרחבות ללולאות או למבני בקרה אחרים,
הנתונים הסטטיסטיים פחות מועילים --- הם מדווחים רק על הקו שבו מתקשרת המאקרו
מופיע. אם פקודות המאקרו המורכבות שלך מתנהגות כמו פונקציות, תוכל להחליף אותן בשורה
פונקציות כדי לפתור בעיה זו.

gcov יוצר קובץ יומן שנקרא sourcefile.gcov מה שמציין כמה פעמים כל שורה של
קובץ מקור sourcefile.c הוציא להורג. אתה יכול להשתמש בקבצי יומן אלה יחד עם gprof ל
לסייע בכוונון עדין של ביצועי התוכניות שלך. gprof נותן לך מידע על תזמון
יכול להשתמש יחד עם המידע שממנו אתה מקבל gcov.

gcov עובד רק על קוד הידור עם GCC. זה לא תואם לכל פרופיל אחר
או מנגנון כיסוי בדיקה.

אפשרויות

-h
- עזרה
הצג עזרה לגבי השימוש gcov (על הפלט הסטנדרטי), וצא מבלי לעשות דבר
עיבוד נוסף.

-v
--גִרְסָה
הצג את gcov מספר גרסה (בפלט הסטנדרטי), וצא מבלי לעשות דבר
עיבוד נוסף.

-a
-- כל הבלוקים
כתוב ספירות ביצוע בודדות עבור כל בלוק בסיסי. בדרך כלל פלטי gcov
ביצוע סופר רק עבור הבלוקים הראשיים של קו. עם אפשרות זו אתה יכול
לקבוע אם בלוקים בתוך שורה בודדת אינם מבוצעים.

-b
--סניף-הסתברויות
כתוב תדרי ענף לקובץ הפלט, וכתוב מידע סיכום ענף ל-
פלט סטנדרטי. אפשרות זו מאפשרת לך לראות באיזו תדירות כל סניף בתוכנית שלך
נלקח. סניפים ללא תנאי לא יוצגו, אלא אם כן -u ניתנת אפשרות.

-c
--סניפי-ספירות
כתוב את תדירויות הסניפים כמספר הענפים שנלקחו, במקום האחוז
של ענפים שנלקחו.

-n
--אין פלט
אל תיצור את gcov קובץ פלט.

-l
-- שמות קבצים ארוכים
צור שמות קבצים ארוכים עבור קובצי מקור כלולים. לדוגמה, אם קובץ הכותרת xh
מכיל קוד, ונכלל בקובץ ac, ואז רץ gcov על הקובץ ac
יפיק קובץ פלט בשם ac##xhgcov במקום xhgcov. זה יכול להיות
שימושי אם xh כלול במספר קובצי מקור ואתה רוצה לראות את הפרט
תרומות. אם אתה משתמש ב- -p אפשרות, גם שמות הקבצים הכלולים וגם שמות הקבצים הכלולים
יהיו שמות נתיבים שלמים.

-p
--שימור-נתיבים
שמור מידע מלא על הנתיב בשמות שנוצרו .gcov קבצים. לְלֹא
אפשרות זו, נעשה שימוש רק ברכיב שם הקובץ. עם אפשרות זו, כל המדריכים
משמשים, עם / תווים מתורגמים ל # תווים, . רכיבי ספרייה הוסרו
ובלתי ניתן להסרה .. שמו של רכיבים ל ^. זה שימושי אם יש קבצי מקור
מספר מדריכים שונים.

-r
--יחסי בלבד
פלט רק מידע על קבצי מקור עם שם נתיב יחסי (אחרי מקור
מחיקת קידומת). נתיבים מוחלטים הם בדרך כלל קבצי כותרות מערכת וכיסוי של כל קובץ
פונקציות מוטבעות בו בדרך כלל לא מעניינות.

-f
--סיכומי פונקציות
פלט סיכומים עבור כל פונקציה בנוסף לסיכום ברמת הקובץ.

-o ספרייה|קובץ
---object-directory בספרייה
--אובייקט-קובץ פילה
ציין את הספרייה המכילה את קובצי הנתונים gcov, או את שם נתיב האובייקט.
השמיים .gcno, ו .gcda מחפשים קבצי נתונים באמצעות אפשרות זו. אם ספרייה היא
שצוין, קבצי הנתונים נמצאים בספרייה זו ונקראים על שם קובץ הקלט,
ללא הרחבה שלו. אם מצוין כאן קובץ, קבצי הנתונים נקראים על שמם
הקובץ הזה, ללא הסיומת שלו.

-s בספרייה
--תחילית מקור בספרייה
קידומת לשמות קבצי מקור להסרה בעת יצירת קובצי כיסוי הפלט.
אפשרות זו שימושית בעת בניית ספרייה נפרדת, ואת שם הנתיב ל-
ספריית מקור אינה רצויה בעת קביעת שמות קבצי הפלט. שימו לב שזה
זיהוי קידומת מוחל לפני קביעה אם קובץ המקור הוא מוחלט.

-u
--ענפים ללא תנאי
כאשר ניתנות הסתברויות ענפים, כלול את אלו של ענפים בלתי מותנים.
ענפים ללא תנאים בדרך כלל אינם מעניינים.

-d
--תצוגה-התקדמות
הצג את ההתקדמות בפלט הסטנדרטי.

-i
--פורמט בינוני
פלט קובץ gcov בפורמט טקסט ביניים קל לניתוח שניתן להשתמש בו lcov
או כלים אחרים. הפלט הוא יחיד .gcov קובץ לכל .gcda קוֹבֶץ. אין קוד מקור
נדרש.

הפורמט של הביניים .gcov הקובץ הוא טקסט רגיל עם ערך אחד בכל שורה

קוֹבֶץ:
פוּנקצִיָה: , ,
ספירה: ,
ענף: ,

איפה ה הוא
notexec (הענף לא בוצע)
נלקח (ענף הוצא להורג ונלקח)
nottaken (הענף הוצא להורג, אך לא נלקח)

יכולים להיות מרובים ערכים ב-gcov ביניים
קוֹבֶץ. כל הערכים בעקבות א שייכים לקובץ המקור הזה
עד הבא כְּנִיסָה.

הנה דוגמה מתי -i משמש בשילוב עם -b אפשרות:

file:array.cc
function:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
פונקציה:22,1,ראשי
מספר: 11,1
מספר: 12,1
מספר: 14,1
סניף:14,נלקח
מספר: 26,1
סניף:28,לא נלקח

-m
--שמות מעורפלים
הצג שמות פונקציות משוחררות בפלט. ברירת המחדל היא להציג פונקציה מעוותת
שמות.

gcov יש להפעיל את הספרייה הנוכחית זהה לזה כאשר הפעלת את
מַהְדֵר. אחרת הוא לא יוכל לאתר את קבצי המקור. gcov מייצר קבצים
נקרא mangledname.gcov בספרייה הנוכחית. אלה מכילים את מידע הכיסוי
של קובץ המקור שהם מתאימים אליו. אחד .gcov קובץ מופק עבור כל מקור (או
header) המכיל קוד, אשר הורכב כדי לייצר את קובצי הנתונים. ה
שם מעוות חלק משם קובץ הפלט הוא בדרך כלל פשוט שם קובץ המקור, אבל יכול
להיות משהו יותר מסובך אם -l or -p ניתנות אפשרויות. עיין באפשרויות הללו
לקבלת פרטים.

אם אתה קורא gcov עם קבצי קלט מרובים, התרומות מכל קובץ קלט הן
סיכם. בדרך כלל תפעיל אותו עם אותה רשימת קבצים כמו הקישור הסופי של
קובץ ההפעלה שלך.

השמיים .gcov קבצים מכילים את : שדות מופרדים יחד עם קוד המקור של התוכנית. הפורמט
is

: :

מידע חסימה נוסף עשוי לצלוח כל שורה, כאשר תתבקש על ידי אפשרות שורת הפקודה.
השמיים ספירת_ביצוע is - עבור שורות שאינן מכילות קוד. שורות שלא בוצעו מסומנות #####
or ====, תלוי אם ניתן להגיע אליהם בנתיבים לא חריגים או רק
נתיבים חריגים כגון C++ מטפלי חריגים, בהתאמה.

כמה שורות מידע בהתחלה יש מספר קו של אפס. שורות ההקדמה הללו הן
של הטופס

-:0: :

ההזמנה והמספר של שורות ההקדמה הללו יוגדלו כ gcov פיתוח
מתקדם --- אל תסמוך על כך שהם יישארו ללא שינוי. להשתמש תג לאתר מסוים
שורת ההקדמה.

מידע החסימה הנוסף הוא מהטופס



השמיים מידע הוא קריא אנושי, אבל תוכנן להיות פשוט מספיק עבור ניתוח מכונה
מדי.

בעת הדפסה של אחוזים, 0% ו-100% מודפסים רק כאשר הערכים הם בדיוק 0% ו
100% בהתאמה. ערכים אחרים שבאופן רגיל היו מעוגלים ל-0% או 100%.
במקום זאת מודפס כערך הלא-גבול הקרוב ביותר.

כשמשתמש gcov, תחילה עליך להרכיב את התוכנית שלך עם שתי אפשרויות מיוחדות של GCC:
-fprofile-arcs -הכיסוי הגבוה ביותר. זה אומר למהדר ליצור עוד
מידע הדרוש ל-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:#include
-: 2:
-: 3:int main (void)
1: 4:{
1: 5: int i, סך הכל;
-: 6:
1: 7: סה"כ = 0;
-: 8:
11: 9: עבור (i = 0; i < 10; i++)
10: 10: סך += i;
-: 11:
1: 12: if (סה"כ != 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:#include
-: 2:
-: 3:int main (void)
1: 4:{
1: 4 בלוק 0
1: 5: int i, סך הכל;
-: 6:
1: 7: סה"כ = 0;
-: 8:
11: 9: עבור (i = 0; i < 10; i++)
11: 9 בלוק 0
10: 10: סך += i;
10: 10 בלוק 0
-: 11:
1: 12: if (סה"כ != 45)
1: 12 בלוק 0
#####: 13: printf ("כשל\n");
$$$$$: 13 בלוק 0
-: 14: אחר
1: 15: printf ("הצלחה\n");
1: 15 בלוק 0
1: 16: החזר 0;
1: 16 בלוק 0
-: 17:}

במצב זה, כל בלוק בסיסי מוצג רק בשורה אחת - השורה האחרונה של הבלוק. א
בלוק מרובה שורות יתרום רק לספירת הביצוע של אותה שורה אחרונה, ואחרות
שורות לא יוצגו כמכילות קוד, אלא אם בלוקים קודמים מסתיימים בשורות אלו. ה
ספירת הביצוע הכוללת של שורה מוצגת והשורות הבאות מציגות את ספירת הביצוע
עבור בלוקים בודדים המסתיימים בקו זה. לאחר כל חסימה, הסניף והקריאה נחשבים
של הבלוק יוצג, אם -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:#include
-: 2:
-: 3:int main (void)
הפונקציה main שנקראה 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: סך += i;
-: 11:
1: 12: if (סה"כ != 45)
ענף 0 נלקח 0% (נפילה)
סניף 1 נלקח 100%
#####: 13: printf ("כשל\n");
שיחה 0 לא בוצעה מעולם
-: 14: אחר
1: 15: printf ("הצלחה\n");
התקשר 0 התקשר 1 החזיר 100%
1: 16: החזר 0;
-: 17:}

עבור כל פונקציה מודפסת שורה שמראה כמה פעמים נקראת הפונקציה, איך
פעמים רבות הוא חוזר ואיזה אחוז מהבלוקים של הפונקציה בוצעו.

עבור כל בלוק בסיסי, מודפסת שורה אחרי השורה האחרונה של הבלוק הבסיסי המתאר
הסניף או השיחה שמסיימים את החסימה הבסיסית. יכולים להיות מספר סניפים ושיחות
רשום עבור שורת מקור בודדת אם יש מספר בלוקים בסיסיים המסתיימים באותה שורה.
במקרה זה, לכל הסניפים והשיחות ניתן מספר. אין דרך פשוטה לעשות זאת
מפה את הענפים הללו וקריאות חזרה למבני מקור. באופן כללי, עם זאת, הנמוך ביותר
סניף או שיחה ממוספרים יתאימו למבנה השמאלי ביותר בקו המקור.

עבור סניף, אם הוא בוצע לפחות פעם אחת, אז אחוז המציין את מספר
הפעמים שהסניף נלקח חלקי מספר הפעמים שהסניף בוצע
מודפס. אחרת, ההודעה "מעולם לא בוצעה" תודפס.

עבור שיחה, אם היא בוצעה לפחות פעם אחת, אז אחוז המציין את מספר
הפעמים שבהן השיחה חזרה חלקי מספר הפעמים שהשיחה בוצעה יהיו
מודפס. זה יהיה בדרך כלל 100%, אבל עשוי להיות פחות עבור פונקציות שקוראות "יציאה" או
"longjmp", ולכן לא יחזור בכל פעם שהם נקראים.

ספירות הביצוע הן מצטברות. אם התוכנית לדוגמה הופעלה שוב ללא
הסרת .gcda קובץ, הספירה של מספר הפעמים שכל שורה במקור הייתה
המבוצע יתווסף לתוצאות של הריצה הקודמת. זה עשוי להיות שימושי
בכמה דרכים. לדוגמה, זה יכול לשמש כדי לצבור נתונים על מספר
התוכנית פועלת כחלק מחבילת אימות בדיקה, או כדי לספק מדויק יותר לטווח ארוך
מידע על מספר רב של ריצות תוכניות.

הנתונים ב- .gcda הקבצים נשמרים מיד לפני יציאת התוכנית. לכל אחד
קובץ המקור שהורכב עם -fprofile-arcs, קוד הפרופיל מנסה לראשונה לקרוא ב-
קיימים .gcda קוֹבֶץ; אם הקובץ אינו תואם לקובץ ההפעלה (מספר שונה של בסיסי
ספירת חסימות) זה יתעלם מתוכן הקובץ. לאחר מכן הוא מוסיף את הביצוע החדש
סופר ולבסוף כותב את הנתונים לקובץ.

שימוש gcov עם GCC אופטימיזציה

אם אתה מתכנן להשתמש gcov כדי לסייע באופטימיזציה של הקוד שלך, תחילה עליך להרכיב את התוכנית שלך
עם שתי אפשרויות מיוחדות של GCC: -fprofile-arcs -הכיסוי הגבוה ביותר. חוץ מזה, אתה יכול
להשתמש בכל אפשרויות אחרות של GCC; אבל אם אתה רוצה להוכיח שכל שורה בתוכנית שלך
הוצא להורג, לא כדאי לבצע קומפילציה עם אופטימיזציה בו-זמנית. בחלק מהמכונות
האופטימיזציה יכולה לבטל כמה שורות קוד פשוטות על ידי שילובן עם שורות אחרות.
לדוגמה, קוד כזה:

אם (א != ב)
c = 1;
אחר
c = 0;

ניתן להרכיב להוראה אחת במכונות מסוימות. במקרה זה, אין דרך לעשות זאת
gcov לחשב ספירות ביצוע נפרדות עבור כל שורה כי אין בנפרד
קוד עבור כל שורה. מכאן ה gcov הפלט נראה כך אם הידור של התוכנית
עם אופטימיזציה:

100: 12:אם (א != ב)
100: 13: c = 1;
100:14:אחרת
100: 15: c = 0;

הפלט מראה שבלוק קוד זה, בשילוב אופטימיזציה, הופעל 100 פעמים.
במובן מסוים התוצאה הזו נכונה, כי הייתה רק הוראה אחת שמייצגת
כל ארבעת השורות הללו. עם זאת, הפלט אינו מציין כמה פעמים התוצאה
היה 0 וכמה פעמים התוצאה הייתה 1.

פונקציות הניתנות לאשורה יכולות ליצור ספירות שורות בלתי צפויות. ספירת השורות מוצגת עבור
קוד המקור של הפונקציה הניתנת לשורה, אבל מה שמוצג תלוי איפה הפונקציה נמצאת
מוטבע, או אם הוא אינו מוטבע כלל.

אם הפונקציה אינה מוטבעת, על המהדר לפלוט עותק לא מקוון של ה-
function, בכל קובץ אובייקט שצריך את זה. אם fileA.o ו fileB.o שניהם מכילים מתוך
גופי קו של פונקציה מסוימת שאינה ניתנת לשורה, שניהם גם יכילו כיסוי
נחשב עבור הפונקציה הזו. מתי fileA.o ו fileB.o מקושרים יחד, המקשר יהיה,
במערכות רבות, בחר אחד מאותם גופים מחוץ לקו עבור כל הקריאות לפונקציה הזו,
ולהסיר או להתעלם מהאחר. למרבה הצער, זה לא יסיר את מוני הכיסוי
עבור גוף התפקוד שאינו בשימוש. מכאן שכאשר מכשיר, כל פרט לאחד השימוש בפונקציה זו
יציג אפס ספירות.

אם הפונקציה מוטבעת במספר מקומות, מבנה הבלוק בכל מיקום עשוי
לא להיות אותו הדבר. לדוגמה, תנאי יכול כעת להיות ניתן לחישוב בזמן הידור ב
מקרים מסוימים. מכיוון שהכיסוי של כל השימושים של הפונקציה המוטבעת יוצג
עבור אותן שורות מקור, ספירת השורות עצמה עשויה להיראות לא עקבית.

יישומים ארוכי טווח יכולים להשתמש במתקנים "_gcov_reset" ו-"_gcov_dump" כדי
הגבל את איסוף הפרופילים לאזור התוכנית המעניין. קורא "_gcov_reset(void)"
ימחק את כל מוני הפרופיל לאפס, וקריאה "_gcov_dump(void)" תגרום ל
מידע פרופיל שנאסף באותה נקודה כדי להזרק אליו .gcda קבצי פלט.

השתמש ב-alpha-linux-gnu-gcov באינטרנט באמצעות שירותי onworks.net