valgrind.bin - מקוון בענן

תָכְנִית:

שֵׁם

valgrind - חבילת כלים עבור תוכניות איתור באגים ופרופילים

תַקצִיר

ולגרינד [אפשרויות valgrind] [התוכנית שלך] [אפשרויות-התוכנית שלך]

תיאור

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

חלק מהאפשרויות המתוארות להלן עובדות עם כל כלי Valgrind, וחלק עובדות רק עם
כמה או אחד. הסעיף MEMCHECK OPTIONS ואלה שמתחתיו מתארים ספציפיים לכלי
אפשרויות.

דף מדריך זה מכסה רק שימוש ואפשרויות בסיסיות. למידע מקיף יותר,
אנא עיין בתיעוד HTML במערכת שלך:
$INSTALL/share/doc/valgrind/html/index.html, או באינטרנט:
http://www.valgrind.org/docs/manual/index.html.

כלי בחירת אפשרויות

האפשרות החשובה ביותר.

--כלי= [בְּרִירַת מֶחדָל: memcheck]
הפעל את הכלי Valgrind שנקרא שם כלי, למשל memcheck, cachegrind, callgrind, helgrind,
drd, massif, lackey, none, exp-sgcheck, exp-bbv, exp-dhat וכו'.

בסיסי אפשרויות

אפשרויות אלה פועלות עם כל הכלים.

-h - עזרה
הצג עזרה עבור כל האפשרויות, הן עבור הליבה והן עבור הכלי שנבחר. אם האפשרות
חוזר על עצמו זה שווה ערך לנתינה ---help-debug.

---help-debug
כמו - עזרה, אלא גם מפרט אפשרויות ניפוי באגים שבדרך כלל מועילות רק עבורם
המפתחים של Valgrind.

--גִרְסָה
הצג את מספר הגרסה של ליבת Valgrind. לכלים יכולים להיות גרסה משלהם
מספרים. ישנה תוכנית שמבטיחה שכלים יפעלו רק כאשר הליבה
גרסה היא אחת שהם ידועים לעבוד איתה. זה נעשה כדי למזער את הסיכויים
בעיות מוזרות הנובעות מאי התאמה של גרסת כלי מול ליבה.

-q, --שֶׁקֶט
הפעל בשקט, והדפיס רק הודעות שגיאה. שימושי אם אתה מפעיל רגרסיה
בדיקות או מנגנון בדיקה אוטומטי אחר.

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

--עקבות-ילדים= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Valgrind יתחקה לתוך תהליכי משנה שיוזמו באמצעות Exec מערכת
שִׂיחָה. זה הכרחי עבור תוכניות מרובות תהליכים.

שימו לב שאלגרינד אכן מתחקה לתוך הילד של א מזלג (יהיה קשה שלא,
since מזלג עושה עותק זהה של תהליך), כך שניתן לטעון שהאפשרות הזו גרועה
בשם. עם זאת, רוב הילדים של מזלג שיחות מיד להתקשר Exec בכל מקרה.

--trace-children-skip=patt1,patt2,...
אפשרות זו משפיעה רק כאשר --עקבות-ילדים=כן מצוין. זה מאפשר
יש לדלג על כמה ילדים. האפשרות לוקחת רשימה מופרדת בפסיק של תבניות עבור
שמות של קובצי הפעלה ילדים שאסור ל-Valgrind להתחקות אחריהם. דפוסים עשויים
לכלול את המטא-תווים? ו-*, שיש להם את המשמעות הרגילה.

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

--trace-children-skip-by-arg=patt1,patt2,...
זה אותו דבר כמו --עקבות-ילדים-דלג, בהבדל אחד: ההחלטה באשר
האם להתחקות לתוך ילד תהליך נעשה על ידי בחינת הטיעונים לילד
תהליך, במקום השם של קובץ ההפעלה שלו.

--ילד-שקט-אחר-מזלג= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Valgrind לא יציג שום פלט ניפוי באגים או רישום עבור הילד
תהליך הנובע מא מזלג שִׂיחָה. זה יכול להפוך את הפלט לפחות מבלבל (אם כי
מטעה יותר) כאשר עוסקים בתהליכים שיוצרים ילדים. זה במיוחד
שימושי בשילוב עם --עקבות-ילדים=. השימוש באפשרות זו הוא גם חזק
מומלץ אם אתה מבקש פלט XML (--xml=כן), שכן אחרת ה-XML מ
ילד והורה עלולים להתערבב, מה שבדרך כלל הופך את זה לחסר תועלת.

--vgdb= [בְּרִירַת מֶחדָל: כן]
Valgrind תספק פונקציונליות של "gdbserver" כאשר --vgdb=כן or --vgdb=מלא is
נָקוּב. זה מאפשר למפרק באגים חיצוני של GNU GDB לשלוט ולתקן באגים בתוכנית שלך
כאשר הוא פועל על Valgrind. --vgdb=מלא כרוך בתקורות ביצועים משמעותיות, אבל
מספק נקודות שבירה ונקודות שמירה מדויקות יותר. ראה איתור באגים בתוכנית שלך באמצעות
ה-gdbserver של Valgrind ו-GDB לתיאור מפורט.

אם שרת ה-gdb המוטבע מופעל אך אין כרגע שימוש ב-gdb, ה-vgdb
כלי השירות של שורת הפקודה יכול לשלוח "פקודות צג" ל-Valgrind מתוך מעטפת. ה
ליבת Valgrind מספקת קבוצה של פקודות צג Valgrind. כלי יכול אופציונלי
לספק פקודות צג ספציפיות לכלי, המתועדות בכלי הספציפי
פרק.

--vgdb-error= [בְּרִירַת מֶחדָל: 999999999]
השתמש באפשרות זו כאשר Valgrind gdbserver מופעל עם --vgdb=כן or --vgdb=מלא.
כלים המדווחים על שגיאות ימתינו לדיווח על שגיאות "מספר" לפני ההקפאה
התוכנית ומחכה שתתחבר עם GDB. מכאן נובע שערך של אפס
יגרום לשרת gdb להיות מופעל לפני הפעלת התוכנית שלך. זה
משמש בדרך כלל להכנסת נקודות עצירה של GDB לפני ביצוע, ועובד גם עם כלים
שאינם מדווחים על שגיאות, כגון Massif.

--vgdb-stop-at= [בְּרִירַת מֶחדָל: אף אחד]
השתמש באפשרות זו כאשר Valgrind gdbserver מופעל עם --vgdb=כן or --vgdb=מלא.
שרת Valgrind gdb יופעל עבור כל שגיאה לאחר מכן --vgdb-error היה
דיווח. אתה יכול בנוסף לבקש משרת Valgrind להיות מופעל עבור אחר
אירועים, המפורטים באחת מהדרכים הבאות:

· רשימה מופרדת בפסיקים של אחד או יותר סטארט - אפ יציאה valgrindabexit.

הערכים סטארט - אפ יציאה valgrindabexit ציין בהתאמה להפעיל את gdbserver
לפני הפעלת התוכנית שלך, לאחר ההוראה האחרונה של התוכנית שלך, הפעל
יציאה חריגה של Valgrind (למשל שגיאה פנימית, חסר זיכרון, ...).

הערה: סטארט - אפ ו --vgdb-error=0 שניהם יגרמו להפעיל את Valgrind gdbserver
לפני הפעלת התוכנית שלך. ה --vgdb-error=0 יגרום בנוסף שלך
תוכנית לעצור על כל השגיאות הבאות.

· את כל כדי לציין את הסט המלא. זה שווה ערך ל
--vgdb-stop-at=startup,exit,valgrindabexit.

· אף לא אחד עבור הסט הריק.

--track-fds= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Valgrind ידפיס רשימה של מתארי קבצים פתוחים ביציאה או ביציאה
בקשה, דרך הפקודה gdbserver monitor v.info open_fds. יחד עם כל קובץ
מתאר מודפס ערימה אחורה של המקום שבו הקובץ נפתח וכל פרט
הקשורים לתיאור הקובץ כגון שם הקובץ או פרטי השקע.

---time-stamp= [בְּרִירַת מֶחדָל: לא]
כאשר מופעלת, לפני כל הודעה יש אינדיקציה של שעון הקיר שחלף
זמן מאז ההפעלה, מבוטא בימים, שעות, דקות, שניות ומילי-שניות.

--log-fd= [בְּרִירַת מֶחדָל: 2, סטדר]
מציין כי Valgrind צריך לשלוח את כל ההודעות שלו לקובץ שצוין
מתאר. ברירת המחדל, 2, היא ערוץ השגיאה הסטנדרטי (stderr). שימו לב שזה עשוי
להפריע לשימוש של הלקוח עצמו ב-stderr, כפי שתהיה הפלט של Valgrind
משולב עם כל פלט שהלקוח שולח ל-stderr.

--log-file=
מציין כי Valgrind צריך לשלוח את כל ההודעות שלו לקובץ שצוין. אם ה
שם הקובץ ריק, הוא גורם לביטול. ישנם שלושה מפרטי פורמט מיוחדים
ניתן להשתמש בשם הקובץ.

%p מוחלף במזהה התהליך הנוכחי. זה מאוד שימושי עבור תוכנית כזו
להפעיל מספר תהליכים. אזהרה: אם אתה משתמש --עקבות-ילדים=כן והתוכנית שלך
מפעיל מספר תהליכים או שהתוכנית שלך מתפצלת מבלי לקרוא ל-exec לאחר מכן, ו
אתה לא משתמש במפרט הזה (או ב %q המפרט למטה), פלט Valgrind מכל
תהליכים אלה ייכנסו לקובץ אחד, אולי מבולבל, ואולי לא שלם.

%q{FOO} מוחלף בתוכן של משתנה הסביבה FOO. אם {FOO}
חלק פגום, הוא גורם להפלה. מפרט זה נחוץ לעתים רחוקות, אבל מאוד
שימושי בנסיבות מסוימות (למשל בעת הפעלת תוכניות MPI). הרעיון הוא שאתה
ציין משתנה אשר יוגדר באופן שונה עבור כל תהליך בעבודה, עבור
דוגמה BPROC_RANK או כל מה שמתאים בהגדרת ה-MPI שלך. אם השם
משתנה הסביבה אינו מוגדר, הוא גורם לביטול. שים לב שבחלק מהקונכיות, ה {
ו } ייתכן שיהיה צורך להוציא תווים עם קו נטוי אחורי.

%% מוחלף ב %.

אם % אחריו כל דמות אחרת, זה גורם להפלה.

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

--log-socket=
מציין כי Valgrind צריכה לשלוח את כל ההודעות שלה ליציאה שצוינה ב-
כתובת IP שצוינה. ניתן להשמיט את היציאה, ובמקרה זה נעשה שימוש ביציאה 1500. אם
לא ניתן ליצור חיבור לשקע שצוין, Valgrind חוזר לכתוב
פלט לשגיאה הסטנדרטית (stderr). אפשרות זו מיועדת לשימוש ב
בשילוב עם תוכנית המאזינים ולגרינד. לפרטים נוספים, ראה את
פרשנות במדריך.

קשור לשגיאות אפשרויות

אפשרויות אלה משמשות את כל הכלים שיכולים לדווח על שגיאות, למשל Memcheck, אבל לא
Cachegrind.

--xml= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, החלקים החשובים של הפלט (למשל הודעות שגיאה בכלי) יהיו בפנים
פורמט XML במקום טקסט רגיל. יתר על כן, פלט ה-XML יישלח אל a
ערוץ פלט שונה מפלט הטקסט הרגיל. לכן, אתה גם חייב להשתמש באחד
of --xml-fd, --xml-קובץ or --xml-socket כדי לציין לאן יש לשלוח את ה-XML.

הודעות פחות חשובות עדיין יודפסו בטקסט רגיל, אבל בגלל ה-XML
פלט ופלט טקסט רגיל נשלחים לערוצי פלט שונים (היעד של
פלט הטקסט הפשוט עדיין נשלט על ידי --log-fd, --קובץ לוג ו ---log-socket)
זה לא אמור לגרום לבעיות.

אפשרות זו מכוונת להקל על החיים עבור כלים שצורכים את הפלט של Valgrind כמו
קלט, כגון ממשקי GUI. כרגע אפשרות זו עובדת עם Memcheck, Helgrind,
DRD ו-SGcheck. פורמט הפלט מצוין בקובץ
docs/internals/xml-output-protocol4.txt בעץ המקור עבור Valgrind 3.5.0 או
מאוחר יותר.

האפשרויות המומלצות למעבר ממשק משתמש, בעת בקשת פלט XML, הן: --xml=כן
כדי לאפשר פלט XML, --xml-קובץ לשלוח את פלט ה-XML ל- (כנראה שנבחר GUI)
קובץ, --קובץ לוג כדי לשלוח את פלט הטקסט הפשוט לקובץ שני שנבחר ב-GUI,
--ילד-שקט-אחר-מזלג=כן, ו -q כדי להגביל את פלט הטקסט הפשוט לקריטי
הודעות שגיאה שנוצרו על ידי Valgrind עצמה. לדוגמה, אי קריאת מסמך מסוים
קובץ דיכוי נחשב כהודעת שגיאה קריטית. בדרך זו, להצלחה
הפעל את קובץ פלט הטקסט יהיה ריק. אבל אם הוא לא ריק, אז הוא יכיל
מידע חשוב שמשתמש ה-GUI צריך להיות מודע אליו.

--xml-fd= [בְּרִירַת מֶחדָל: -1, נָכֶה]
מציין כי Valgrind צריך לשלוח את פלט ה-XML שלו אל מתאר הקובץ שצוין.
יש להשתמש בו בשילוב עם --xml=כן.

--xml-file=
מציין כי Valgrind צריך לשלוח את פלט ה-XML שלו לקובץ שצוין. זה חייב להיות
בשימוש בשילוב עם --xml=כן. כל %p or %q רצפים המופיעים בשם הקובץ
מורחבים בדיוק באותו אופן שבו הם מיועדים --קובץ לוג. ראה את התיאור
of --קובץ לוג לקבלת פרטים.

--xml-socket=
מציין כי Valgrind צריך לשלוח את פלט ה-XML שלו את היציאה שצוינה בנקודה שצוינה
כתובת ה - IP. יש להשתמש בו בשילוב עם --xml=כן. צורת הטיעון היא
זהה לזה שבו משתמשים ---log-socket. ראה את התיאור של ---log-socket עוד
פרטים.

--xml-user-comment=
הטמעת מחרוזת הערות משתמש נוספת בתחילת פלט ה-XML. עובד רק כאשר
--xml=כן צוין; התעלמו אחרת.

--demangle= [בְּרִירַת מֶחדָל: כן]
הפעל/השבת את ה-demangelling (פענוח) אוטומטי של שמות C++. מופעל כברירת מחדל. מתי
מופעל, Valgrind ינסה לתרגם שמות C++ מקודדים בחזרה למשהו
מתקרב למקור. ה-demangler מטפל בסמלים מעוותים על ידי g++ גרסאות 2.X,
3.X ו-4.X.

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

--num-callers= [בְּרִירַת מֶחדָל: 12]
מציין את המספר המרבי של ערכים המוצגים במעקבי מחסנית המזהים תוכנית
מיקומים. שים לב ששגיאות נפוצות רק באמצעות ארבעת מיקומי הפונקציות המובילים
(המקום בפונקציה הנוכחית, ושל שלושת המתקשרים המיידיים שלו). אז זה
לא משפיע על המספר הכולל של שגיאות שדווחו.

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

--unw-stack-scan-thresh= [בְּרִירַת מֶחדָל: 0] , --unw-stack-scan-frames= [בְּרִירַת מֶחדָל:
5]
תמיכה בסריקת מחסנית זמינה רק ביעדי ARM.

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

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

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

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

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

כברירת מחדל, סריקת מחסנית מושבתת. מקרה השימוש הרגיל הוא לבקש זאת כאשר א
מעקב מחסנית יהיה קצר מאוד. אז, כדי לאפשר את זה, השתמש
--unw-stack-scan-thresh=מספר. זה מבקש מאלגרינד לנסות להשתמש בסריקת מחסנית
"להרחיב" עקבות מחסנית המכילות פחות מסגרות מספר.

אם אכן מתבצעת סריקת מחסנית, היא תייצר רק את מספר הפריימים לכל היותר
שצוין על ידי --unw-stack-scan-frames. בדרך כלל, סריקת מחסנית מייצרת כל כך הרבה
ערכי זבל שערך זה מוגדר לערך נמוך (5) כברירת מחדל. בשום מקרה לא
נוצר עקבות מחסנית גדולה מהערך שצוין על ידי --num-callers.

--error-limit= [בְּרִירַת מֶחדָל: כן]
כאשר מופעל, Valgrind מפסיק לדווח על שגיאות לאחר 10,000,000 בסך הכל, או 1,000
שונים, נראו. זה כדי לעצור את מכונות מעקב השגיאות
הופכים לתקורת ביצועים ענקית בתוכניות עם שגיאות רבות.

--error-exitcode= [בְּרִירַת מֶחדָל: 0]
מציין קוד יציאה חלופי להחזרה אם Valgrind דיווח על שגיאות כלשהן ב-
לָרוּץ. כאשר מוגדר לערך ברירת המחדל (אפס), ערך ההחזר מ- Valgrind יהיה תמיד
להיות ערך ההחזר של התהליך המדמה. כאשר מוגדר לערך שאינו אפס, זה
הערך מוחזר במקום זאת, אם Valgrind מזהה שגיאות כלשהן. זה שימושי לשימוש
Valgrind כחלק מחבילת בדיקות אוטומטית, מכיוון שהיא מקלה על זיהוי הבדיקה
מקרים שבהם Valgrind דיווחה על שגיאות, רק על ידי בדיקת קודי החזרה.

--error-markers= , [בְּרִירַת מֶחדָל: אף אחד]
כאשר שגיאות יוצאות כטקסט רגיל (כלומר לא נעשה שימוש ב-XML), --סמני שגיאה מורה ל
פלט שורה המכילה את להתחיל (סוף) מחרוזת לפני (אחרי) כל שגיאה.

קווי סמן כאלה מקלים על חיפוש שגיאות ו/או חילוץ שגיאות ב-an
קובץ פלט שמכיל שגיאות valgrind מעורבות עם פלט התוכנית.

שימו לב שמתקבלים סמנים ריקים. אז, רק שימוש בסמן התחלה (או סיום) הוא
אפשרי.

--sigill-diagnostics= [בְּרִירַת מֶחדָל: כן]
אפשר/השבת הדפסה של אבחון הוראות לא חוקי. מופעל כברירת מחדל, אבל
ברירת המחדל היא מושבתת כאשר --שֶׁקֶט נתון. ברירת המחדל יכולה תמיד להיות במפורש
עוקף על ידי מתן אפשרות זו.

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

--show-below-main= [בְּרִירַת מֶחדָל: לא]
כברירת מחדל, עקבות מחסנית עבור שגיאות אינן מציגות פונקציות המופיעות מתחת ראשי
כי רוב הזמן זה דברים לא מעניינים של ספריית C ו/או gobbledygook.
לחלופין, אם ראשי אינו קיים במעקב הערימה, עקבות הערימה לא יוצגו
כל הפונקציות למטה ראשיפונקציות דמויות כגון glibc's __libc_start_main.
יתר על כן, אם ראשיפונקציות דמויות קיימות בעקיבה, הן מנורמלות כ
(לְהַלָן רָאשִׁי), על מנת להפוך את הפלט ליותר דטרמיניסטי.

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

--fullpath-after= [בְּרִירַת מֶחדָל: לא לְהַצִיג מָקוֹר שבילים]
כברירת מחדל Valgrind מציגה רק את שמות הקבצים בעקבות מחסניות, אך לא נתיבים מלאים
קבצי מקור. כאשר משתמשים ב-Valgriind בפרויקטים גדולים שבהם שוכנים המקורות
מספר ספריות שונות, זה יכול להיות לא נוח. --fullpath-אחרי מספק
פתרון גמיש לבעיה זו. כאשר אפשרות זו קיימת, הנתיב לכל אחד
קובץ המקור מוצג, עם האזהרה הכל כך חשובה הבאה: if מחרוזת נמצא ב
השביל, ואז השביל עד וכולל מחרוזת מושמט, אחרת הנתיב מוצג
ללא שינוי. ציין זאת מחרוזת אינו נדרש להיות קידומת של הנתיב.

לדוגמה, שקול קובץ בשם /home/janedoe/blah/src/foo/bar/xyzzy.c. מפרט
--fullpath-after=/home/janedoe/blah/src/ יגרום לוואלגרינד להציג את השם בתור
foo/bar/xyzzy.c.

מכיוון שהמחרוזת אינה נדרשת להיות קידומת, --fullpath-after=src/ יפיק
אותו פלט. זה שימושי כאשר הנתיב מכיל מכונה שרירותית שנוצרה
דמויות. לדוגמה, הנתיב /my/build/dir/C32A1B47/blah/src/foo/xyzzy יכול להיות
גזם עד foo/xyzzy באמצעות --fullpath-after=/blah/src/.

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

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

--extra-debuginfo-path= [בְּרִירַת מֶחדָל: לא מוגדר ו לא בשימוש]
כברירת מחדל Valgrind מחפש בכמה נתיבים ידועים אחר אובייקטי ניפוי באגים, כגון
/usr/lib/debug/.

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

בתרחישים אלה, אתה עשוי לספק נתיב מוחלט כמקום נוסף וסופי עבור
Valgrind לחיפוש אובייקטי ניפוי באגים על ידי ציון
--extra-debuginfo-path=/path/to/debug/objects. הנתיב הנתון יוצב לפני ה-
שם הנתיב המוחלט של האובייקט המבוקש. לדוגמה, אם Valgrind מחפש
ה-debuginfo עבור /w/x/y/zz.so ו --extra-debuginfo-path=/a/b/c מצוין, זה יהיה
חפש אובייקט לניפוי באגים ב-/a/b/c/w/x/y/zz.so.

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

--debuginfo-server=ipaddr:port [בְּרִירַת מֶחדָל: לא מוגדר ו לא בשימוש]
זוהי תכונה חדשה, ניסיונית, שהוצגה בגרסה 3.9.0.

בתרחישים מסוימים זה עשוי להיות נוח לקרוא מידע באגים מאובייקטים המאוחסנים ב-a
מכונה אחרת. עם הדגל הזה, Valgrind תבצע שאילתות לשרת debuginfo שפועל עליו
ipaddr והאזנה ביציאת היציאה, אם הוא לא יכול למצוא את אובייקט debuginfo ב-local
מערכת קבצים.

שרת debuginfo חייב לקבל חיבורי TCP ביציאת היציאה. שרת debuginfo הוא
הכלול בקובץ המקור auxprogs/valgrind-di-server.c. זה ישרת רק מ
הספרייה שבה היא מופעלת. יציאת ברירת המחדל היא 1500 הן בלקוח והן בשרת אם
לא מוגדר.

אם Valgrind מחפש את debuginfo עבור /w/x/y/zz.so באמצעות שרת debuginfo, זה
יסיר את רכיבי שם הנתיב ורק יבקש zz.so בשרת. זה ב
turn יחפש רק בספריית העבודה הנוכחית שלו אחר אובייקט debuginfo תואם.

נתוני debuginfo מועברים בקטעים קטנים (8 KB) לפי בקשת Valgrind.
כל בלוק נדחס באמצעות LZO כדי להפחית את זמן השידור. ליישום יש
כווננו לביצועים הטובים ביותר באמצעות קישור רשת 802.11g (WiFi) חד-שלבי.

שים לב שבודק התאמת אובייקטים ראשיים לעומת אובייקטי ניפוי באגים, באמצעות GNU debuglink CRC
תוכנית, מבוצעות גם בעת שימוש בשרת debuginfo. כדי להשבית בדיקה כזו,
עליך לציין גם --allow-mismatched-debuginfo=yes.

כברירת מחדל, מערכת הבנייה Valgrind תבנה valgrind-di-server עבור המטרה
פלטפורמה, שזה כמעט בוודאות לא מה שאתה רוצה. עד כה לא הצלחנו
גלה כיצד להשיג את automake/autoconf כדי לבנות אותו עבור פלטפורמת הבנייה. אם אתה רוצה
כדי להשתמש בו, תצטרך להדר אותו מחדש ביד באמצעות הפקודה המוצגת בחלק העליון של
auxprogs/valgrind-di-server.c.

--allow-mismatched-debuginfo=no|yes [לא]
בעת קריאת debuginfo מאובייקטי debuginfo נפרדים, Valgrind כברירת מחדל תבדוק
שהאובייקטים הראשיים ו-debuginfo תואמים, באמצעות מנגנון Debuglink של GNU. זֶה
מבטיח שהוא לא קורא debuginfo מאובייקטי debuginfo מיושנים, וכן
מבטיח גם ש-Valgrind לא יכול לקרוס כתוצאה מחוסר התאמה.

ניתן לעקוף בדיקה זו באמצעות --allow-mismatched-debuginfo=yes. זה יכול להיות
שימושי כאשר ה-debuginfo והאובייקטים הראשיים לא פוצלו בצורה הנכונה. לִהיוֹת
עם זאת, זהירות בעת השימוש: זה משבית את כל בדיקת העקביות ואת Valgrind
נצפה לקרוס כאשר האובייקטים הראשיים ו-debuginfo אינם תואמים.

--הדחקות= [בְּרִירַת מֶחדָל: $PREFIX/lib/valgrind/default.supp]
מציין קובץ נוסף שממנו ניתן לקרוא תיאורים של שגיאות להדחה. אתה יכול
השתמש בעד 100 קבצי דיכוי נוספים.

--gen-suppressions= [בְּרִירַת מֶחדָל: לא]
כאשר מוגדר ל כן, Valgrind תשהה לאחר כל שגיאה שתוצג ותדפיס את השורה:

---- דיכוי הדפסה? --- [Return/N/n/Y/y/C/c] ----

לחיצה Ret, או N Ret or n Ret, גורם ל-Valgrind להמשיך בביצוע ללא הדפסת א
דיכוי עבור שגיאה זו.

לחיצה Y Ret or y Ret גורם ל-Valgrind לכתוב דיכוי עבור שגיאה זו. אתה יכול
לאחר מכן גזור והדבק אותו בקובץ דיכוי אם אינך רוצה לשמוע על
טעות בעתיד.

כאשר מוגדר ל את כל, Valgrind ידפיס דיכוי עבור כל שגיאה מדווחת, ללא
שואל את המשתמש.

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

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

לפעמים שתי שגיאות שונות נדחקות על ידי אותו דיכוי, ובמקרה זה
Valgrind תוציא את הדיכוי יותר מפעם אחת, אבל אתה צריך רק אחד
העתק בקובץ ההדחקה שלך (אבל אם יש יותר מאחד לא יגרום לבעיות). גַם,
שם ההדחקה ניתן כ ; השם לא
באמת משנה, הוא משמש רק עם -v אפשרות שמדפיסה את כל הדיכוי בשימוש
רשום.

--input-fd= [בְּרִירַת מֶחדָל: 0, stdin]
כשמשתמש --gen-suppressions=כן, Valgrind יפסיק כדי לקרוא קלט מקלדת
ממך כאשר כל שגיאה מתרחשת. כברירת מחדל הוא קורא מהקלט הסטנדרטי (stdin),
וזה בעייתי עבור תוכניות שסוגרות stdin. אפשרות זו מאפשרת לך לציין
מתאר קובץ חלופי שממנו ניתן לקרוא קלט.

--dsymutil=לא|כן [כן]
אפשרות זו רלוונטית רק בעת הפעלת Valgrind ב-Mac OS X.

Mac OS X משתמש בסכימת קישור של מידע באגים דחוי (debuginfo). כאשר חפץ
קבצים המכילים debuginfo מקושרים ל-.dylib או לקובץ הפעלה, ה-debuginfo הוא
לא הועתק לקובץ הסופי. במקום זאת, יש לקשר את מידע באגים באופן ידני על ידי
הפעלת dsymutil, כלי עזר שסופק על ידי המערכת, על קובץ ההפעלה או .dylib. ה
מידע על debuginfo המשולב המתקבל ממוקם בספרייה לצד קובץ ההפעלה or
.dylib, אבל עם הסיומת .dSYM.

עם --dsymutil=לא, Valgrind יזהה מקרים שבהם ספריית .dSYM היא אחת מהן
חסר, או קיים אך נראה שאינו תואם לקובץ ההפעלה המשויך או
.dylib, ככל הנראה בגלל שהוא לא מעודכן. במקרים אלו, Valgrind ידפיס א
הודעת אזהרה אך אל תנקוט פעולה נוספת.

עם --dsymutil=כן, Valgrind יפעיל, במקרים כאלה, אוטומטית את dsymutil as
הכרחי כדי לעדכן את נתוני ניפוי הבאגים. לכל המטרות המעשיות, אם תמיד
להשתמש --dsymutil=כן, אז לעולם אין צורך להפעיל את dsymutil באופן ידני או כחלק
ממערכת הבנייה של היישומים שלך, שכן Valgrind תריץ אותה לפי הצורך.

Valgrind לא ינסה להפעיל dsymutil על כל קובץ הפעלה או ספריה ב /usr/,
/ סל /, / sbin /, / העדיף /, /sw/, /System/, /Library/ או /Applications/ שכן dsymutil
תמיד נכשל במצבים כאלה. זה נכשל גם בגלל ה-debuginfo עבור כאלה
רכיבי מערכת מותקנים מראש אינם זמינים בשום מקום, וגם כי הם יהיו זמינים
דורשים הרשאות כתיבה בספריות הללו.

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

--max-stackframe= [בְּרִירַת מֶחדָל: 2000000]
הגודל המרבי של מסגרת מחסנית. אם מצביע הערימה זז ביותר מסכום זה
ואז Valgrind יניח שהתוכנית עוברת לערימה אחרת.

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

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

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

--main-stacksize= [בְּרִירַת מֶחדָל: להשתמש נוֹכְחִי 'ulimit' ערך]
מציין את גודל הערימה של החוט הראשי.

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

כברירת מחדל, Valgrind משתמש בערך "ulimit" הנוכחי עבור גודל הערימה, או 16 MB,
הנמוך מביניהם. במקרים רבים זה נותן גודל מחסנית בטווח של 8 עד 16 מגה-בייט,
אשר כמעט אף פעם לא עולה על גדותיו עבור רוב היישומים.

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

ב-Linux, אתה יכול לבקש ערימה בגודל של עד 2GB. Valgrind יפסיק עם א
הודעת אבחון אם לא ניתן להקצות את המחסנית.

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

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

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

--max-threads= [בְּרִירַת מֶחדָל: 500]
כברירת מחדל, Valgrind יכול להתמודד עם עד 500 שרשורים. מדי פעם, גם המספר הזה
קָטָן. השתמש באפשרות זו כדי לספק מגבלה אחרת. למשל --max-threads=3000.

MALLOC()-RELATED אפשרויות

עבור כלים המשתמשים בגרסה משלהם של malloc (למשל Memcheck, Massif, Helgrind, DRD), ה
האפשרויות הבאות חלות.

--alignment= [בְּרִירַת מֶחדָל: 8 or 16, בהתאם on מה היא פּלַטפוֹרמָה]
כברירת מחדל של Valgrind malloc, ריאלוקוכו', מחזירים בלוק שכתובת ההתחלה שלו היא
מיושר 8-בייט או 16-בייט מיושר (הערך תלוי בפלטפורמה ותואם את
ברירת המחדל של הפלטפורמה). אפשרות זו מאפשרת לך לציין יישור שונה. ה
הערך המסופק חייב להיות גדול או שווה לברירת המחדל, קטן או שווה ל
4096, וחייב להיות חזקה של שתיים.

--redzone-size= [בְּרִירַת מֶחדָל: תלוי on מה היא כְּלִי]
של ולגרינד מאלוק, רילוק, וכו', הוסף קוביות ריפוד לפני ואחרי כל גוש ערימה
מוקצה על ידי התוכנית המופעלת. גושי ריפוד כאלה נקראים אזורים אדומים. ה
ערך ברירת המחדל לגודל האדום תלוי בכלי. לדוגמה, Memcheck מוסיף ו
מגן על מינימום של 16 בתים לפני ואחרי כל בלוק שהוקצה על ידי הלקוח.
זה מאפשר לו לזהות חריגות או חריגות של עד 16 בתים.

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

נָדִיר אפשרויות

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

--smc-check= [בְּרִירַת מֶחדָל: הכל לא קובץ ל x86/amd64/s390x,
לערום ל אַחֵר קשתות]
אפשרות זו שולטת בזיהוי של Valgrind של קוד משתנה עצמי. אם אין בדיקה
נעשה, כאשר תוכנית מבצעת קוד כלשהו, ​​ולאחר מכן מחליפה אותו בקוד חדש, ו
מבצעת את הקוד החדש, Valgrind תמשיך לבצע את התרגומים שעבורם יצרה
הקוד הישן. סביר להניח שזה יוביל להתנהגות שגויה ו/או קריסות.

עבור ארכיטקטורות "מודרניות" -- כל דבר שאינו x86, amd64 או s390x -- ברירת המחדל
is לערום. הסיבה לכך היא שתוכנית נכונה חייבת לנקוט פעולה מפורשת כדי להקים אותה מחדש
קוהרנטיות מטמון DI בעקבות שינוי קוד. Valgrind מתבונן ומכבד כאלה
פעולות, וכתוצאה מכך קוד השינוי העצמי מטופל בשקיפות עם אפס
תשלום נוסף.

עבור x86, amd64 ו-s390x, התוכנית אינה נדרשת להודיע ​​לחומרה על
נדרש סנכרון קוהרנטיות DI. מכאן שברירת המחדל היא הכל לא קובץ, המכסה את
מקרה רגיל של יצירת קוד לאזור mmap'd אנונימי (לא מגובה קבצים).

המשמעויות של ארבע ההגדרות הזמינות הן כדלקמן. אין זיהוי (אף לא אחד),
זיהוי קוד משתנה בעצמו בערימה (המשמשת את GCC ליישום Nested
פונקציות) (לערום), לזהות קוד משתנה בעצמו בכל מקום (את כל), ולזהות
קוד משתנה בעצמו בכל מקום למעט מיפויים מגובים קבצים (הכל לא קובץ).

רץ עם את כל יאט את קצב Valgrind בצורה ניכרת. רצים עם אף לא אחד לעיתים רחוקות
להאיץ את העניינים, מכיוון שמעט מאוד קוד נוצר באופן דינמי ברוב התוכניות.
השמיים VALGRIND_DISCARD_TRANSLATIONS בקשת הלקוח היא חלופה ל --smc-check=all
ו --smc-check=all-non-file זה דורש יותר מאמץ מתכנת אבל מאפשר Valgrind
כדי להפעיל את התוכנית שלך מהר יותר, על ידי כך שתאמר לה בדיוק מתי צריך לתרגם
נעשה מחדש.

--smc-check=all-non-file מספק גרסה זולה יותר אך מוגבלת יותר של
--smc-check=all. זה מוסיף צ'קים לכל תרגום שאינו מקורו
מיפויי זיכרון מגובים בקבצים. יישומים אופייניים שמייצרים קוד, למשל JITs
בדפדפני אינטרנט, צור קוד לאזורים מפורדים אנונימיים, בעוד שהקוד ה"קבוע".
של הדפדפן תמיד חי במיפויים מגובים קבצים. --smc-check=all-non-file לוקח
היתרון של תצפית זו, הגבלת תקורה של בדיקה לקוד שהוא
סביר שייווצר JIT.

--read-inline-info= [בְּרִירַת מֶחדָל: לִרְאוֹת להלן]
כאשר מופעלת, Valgrind תקרא מידע על קריאות פונקציות מוטבעות מ-DWARF3
מידע על ניפוי באגים. זה מאט את ההפעלה של Valgrind וגורם לו להשתמש יותר בזיכרון (בדרך כלל עבור
כל קטע קוד משובץ, 6 מילים ורווח לשם הפונקציה), אבל זה מתקבל
ב-stacktraces תיאוריים יותר. עבור המהדורה 3.10.0, פונקציונליות זו מופעלת
כברירת מחדל רק עבור יעדי לינוקס, אנדרואיד וסולאריס ורק עבור הכלים
ממצ'ק, הלגרינד ו-DRD. הנה דוגמה לכמה מעקבים מחסנים עם
--read-inline-info=no:

==15380== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15380== ב-0x80484EA: main (inlinfo.c:6)
==15380==
==15380== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15380== ב-0x8048550: fun_noninline (inlinfo.c:6)
==15380== לפי 0x804850E: main (inlinfo.c:34)
==15380==
==15380== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15380== ב-0x8048520: main (inlinfo.c:6)

והנה אותן שגיאות עם --read-inline-info=כן:

==15377== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15377== ב-0x80484EA: fun_d (inlinfo.c:6)
==15377== לפי 0x80484EA: fun_c (inlinfo.c:14)
==15377== מאת 0x80484EA: fun_b (inlinfo.c:20)
==15377== מאת 0x80484EA: fun_a (inlinfo.c:26)
==15377== לפי 0x80484EA: main (inlinfo.c:33)
==15377==
==15377== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15377== ב-0x8048550: fun_d (ininfo.c:6)
==15377== לפי 0x8048550: fun_noninline (inlinfo.c:41)
==15377== לפי 0x804850E: main (inlinfo.c:34)
==15377==
==15377== קפיצה או מהלך מותנה תלויים בערכים לא מאותחלים
==15377== ב-0x8048520: fun_d (ininfo.c:6)
==15377== ב-0x8048520: main (inlinfo.c:35)

--read-var-info= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Valgrind יקרא מידע על סוגי משתנים ומיקומים
מידע על ניפוי באגים של DWARF3. זה מאט את ההפעלה של Valgrind באופן משמעותי והופך אותו לשימוש
הרבה יותר זיכרון, אבל בשביל הכלים שיכולים לנצל את זה (Memcheck,
Helgrind, DRD) זה יכול לגרום להודעות שגיאה מדויקות יותר. לדוגמה, הנה
כמה שגיאות סטנדרטיות שהונפקו על ידי Memcheck:

==15363== בתים לא מאותחלים נמצאו במהלך בקשת בדיקת הלקוח
==15363== ב-0x80484A9: קרקור (varinfo1.c:28)
==15363== לפי 0x8048544: main (varinfo1.c:55)
==15363== כתובת 0x80497f7 היא 7 בתים בתוך סמל הנתונים "global_i2"
==15363==
==15363== בתים לא מאותחלים נמצאו במהלך בקשת בדיקת הלקוח
==15363== ב-0x80484A9: קרקור (varinfo1.c:28)
==15363== לפי 0x8048550: main (varinfo1.c:56)
==15363== כתובת 0xbea0d0cc נמצאת בערימה של שרשור 1
==15363== במסגרת #1, נוצר על ידי main (varinfo1.c:45)

והנה אותן שגיאות עם --read-var-info=yes:

==15370== בתים לא מאותחלים נמצאו במהלך בקשת בדיקת הלקוח
==15370== ב-0x80484A9: קרקור (varinfo1.c:28)
==15370== לפי 0x8048544: main (varinfo1.c:55)
==15370== מיקום 0x80497f7 הוא 0 בתים בתוך global_i2[7],
==15370== משתנה גלובלי המוצהר ב-varinfo1.c:41
==15370==
==15370== בתים לא מאותחלים נמצאו במהלך בקשת בדיקת הלקוח
==15370== ב-0x80484A9: קרקור (varinfo1.c:28)
==15370== לפי 0x8048550: main (varinfo1.c:56)
==15370== מיקום 0xbeb4a0cc הוא 0 בתים בתוך var "local" המקומי
==15370== הוצהר ב-varinfo1.c:46, במסגרת מס' 1 של שרשור 1

--vgdb-poll= [בְּרִירַת מֶחדָל: 5000]
כחלק מהלולאה הראשית שלו, מתזמן Valgrind יבצע סקר כדי לבדוק אם יש פעילות כלשהי
(כגון פקודה חיצונית או קלט כלשהו מ-gdb) חייב להיות מטופל על ידי gdbserver.
סקר פעילות זה יתבצע לאחר הפעלת המספר הנתון של בלוקים בסיסיים (או
מעט יותר מהמספר הנתון של בלוקים בסיסיים). הסקר הזה די זול ולכן
ערך ברירת המחדל מוגדר נמוך יחסית. תוכל להקטין עוד יותר את הערך הזה אם vgdb
לא יכול להשתמש בקריאה למערכת ptrace כדי להפריע ל-Valgrind אם כל החוטים הם (רוב ה-
זמן) חסום בשיחת מערכת.

--vgdb-shadow-registers=לא|כן [בְּרִירַת מֶחדָל: לא]
כאשר הוא מופעל, gdbserver יחשוף את אוגרי הצל של Valgrind ל-GDB. עם זה,
ניתן לבחון או לשנות את הערך של אוגרי הצללים של Valgrind באמצעות GDB.
חשיפת אוגרי צל פועלת רק עם GDB גרסה 7.1 ואילך.

--vgdb-prefix= [בְּרִירַת מֶחדָל: /tmp/vgdb-pipe]
כדי לתקשר עם gdb/vgdb, שרת ה-Gdb Valgrind יוצר 3 קבצים (2 בשם FIFOs
וקובץ זיכרון משותף mmap). אפשרות הקידומת שולטת בספרייה ובקידומת
ליצירת קבצים אלה.

--run-libc-freeres= [בְּרִירַת מֶחדָל: כן]
אפשרות זו רלוונטית רק בעת הפעלת Valgrind על לינוקס.

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

מחברי Glibc הבינו שהתנהגות זו גורמת לבודקי דליפות, כגון Valgrind,
לדווח כוזב על דליפות ב-glibc, כאשר מתבצעת בדיקת דליפה ביציאה. על מנת להימנע
זה, הם סיפקו שגרה בשם __libc_freeres במיוחד כדי לשחרר glibc
כל הזיכרון שהוא הקצה. לכן Memcheck מנסה לרוץ __libc_freeres ביציאה.

לרוע המזל, בכמה גרסאות ישנות מאוד של glibc, __libc_freeres הוא מספיק
באגי כדי לגרום לתקלות פילוח. זה היה בולט במיוחד ב-Red Hat 7.1.
אז אפשרות זו ניתנת על מנת לעכב את הריצה של __libc_freeres. אם שלך
נראה שהתוכנית פועלת בסדר ב- Valgrind, אבל תקלות ביציאה, אתה עלול למצוא את זה
--run-libc-freeres=לא מתקן את זה, אם כי במחיר אולי דיווח כוזב
דליפות מקום ב-libc.so.

--sim-hints=רמז1,רמז2,...
העבירו רמזים שונים ל-Valgrind אשר משנים מעט את ההתנהגות המדומה ב
דרכים לא סטנדרטיות או מסוכנות, אולי כדי לסייע בסימולציה של תכונות מוזרות. על ידי
ברירת מחדל אין רמזים מופעלים. השתמש בזהירות! הרמזים הידועים כיום הם:

· lax-ioctls: היה רפוי מאוד בטיפול ב-ioctl; ההנחה היחידה היא שהגודל
זה נכון. לא מחייב אתחול המאגר המלא בעת הכתיבה.
בלי זה, שימוש בכמה מנהלי התקנים עם מספר גדול של ioctl מוזר
הפקודות הופכות מעייפות מאוד.

· תואם פיוז: אפשר טיפול מיוחד עבור שיחות מערכת מסוימות שעלולות לחסום
במערכת קבצים FUSE. זה עשוי להיות נחוץ בעת הפעלת Valgrind על a
תוכנה מרובת הליכי שמשתמשת בחוט אחד לניהול מערכת קבצים FUSE ו
שרשור נוסף כדי לגשת למערכת הקבצים הזו.

· Enable-outer: אפשר קסם מיוחד הדרוש כאשר התוכנית המופעלת היא
עצמו Valgrind.

· ללא קידומת פנימית: השבת הדפסת קידומת > לפני כל stdout או stderr
קו פלט בוולגרינד פנימי המנוהל על ידי וולגרינד חיצוני. זה שימושי
בעת הפעלת מבחני רגרסיה של Valgrind במערך חיצוני/פנימי. שימו לב שה-
קידומת > תמיד יודפס מול שורות רישום הבאגים הפנימיות.

· no-nptl-pthread-stackcache: רמז זה רלוונטי רק בעת הפעלת Valgrind
לינוקס.

ספריית pthread GNU glibc (libpthread.so), המשמש את תוכניות pthread,
שומר על מטמון של ערימות pthread. כאשר pthread מסתיים, הזיכרון בשימוש
עבור מחסנית pthread ומבנה נתונים הקשורים לאחסון מקומי מסויים לא
תמיד משוחרר ישירות. זיכרון זה נשמר במטמון (עד גודל מסוים),
ונעשה בו שימוש חוזר אם נפתח שרשור חדש.

מטמון זה גורם לכלי helgrind לדווח על מצב גזע חיובי שגוי
שגיאות בזיכרון המטמון הזה, שכן helgrind לא מבין את ה-glibc הפנימי
פרימיטיבים של סנכרון מטמון. לכן, בעת שימוש ב- helgrind, השבתת המטמון
עוזר להימנע מתנאי מרוץ חיוביים כוזבים, במיוחד בעת שימוש בחוט
משתני אחסון מקומיים (למשל משתנים המשתמשים ב- __ שלישית מַגְדִיר).

בעת שימוש בכלי memcheck, השבתת המטמון מבטיחה את הזיכרון שבו משתמש glibc
לטפל במשתני __thread משוחרר ישירות כאשר שרשור מסתיים.

הערה: Valgrind משבית את המטמון תוך שימוש בידע פנימי כלשהו של ערימת glibc
הטמעת מטמון ועל ידי בחינת מידע באגים של ה-pthread
סִפְרִיָה. לכן טכניקה זו שברירית במקצת וייתכן שלא תעבוד עבור כל Glibc
גרסאות. זה נבדק בהצלחה עם גרסאות Glibc שונות (למשל
2.11, 2.16, 2.18) בפלטפורמות שונות.

· דלתות רופפות: (סולאריס בלבד) היה רפוי מאוד לגבי טיפול במערכות דלתות
מתארי קבצי דלת לא מזוהים. אינו דורש כי חיץ מלא הוא
אתחול בעת הכתיבה. בלי זה, תוכניות המשתמשות libdoor(3LIB) פונקציונליות
עם סמנטיקה קניינית לחלוטין עשוי לדווח על מספר רב של תוצאות חיוביות שגויות.

--שידור הוגן= [בְּרִירַת מֶחדָל: לא]
השמיים --לוח זמנים הוגן אפשרות שולטת במנגנון הנעילה המשמש את Valgrind להצגה בסידרה
ביצוע חוט. מנגנון הנעילה שולט באופן תזמון החוטים,
והגדרות שונות נותנות פשרות שונות בין הגינות לביצועים. ל
פרטים נוספים על ערכת הסדרת חוט Valgrind והשפעתה על
ביצועים ותזמון שרשורים, ראה תזמון וביצועים מרובי חוטים.

· הערך --fair-sched=כן מפעיל מתזמן הוגן. בקיצור, אם מרובים
השרשורים מוכנים להפעלה, השרשורים יתוכננו בצורה סיבובית.
מנגנון זה אינו זמין בכל הפלטפורמות או גרסאות לינוקס. אם לא
זמין, באמצעות --fair-sched=כן יגרום ל-Valgrind להפסיק עם שגיאה.

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

· הערך --fair-sched=try מפעיל תזמון הוגן אם זמין בפלטפורמה.
אחרת, זה יחזור אוטומטית --fair-sched=לא.

· הערך --fair-sched=לא מפעיל מתזמן שאינו מבטיח הוגנות
בין חוטים מוכנים להפעלה, אבל מה שבאופן כללי נותן את הביצועים הגבוהים ביותר.

--kernel-variant=variant1,variant2,...
טפל בקריאות מערכת וב-ioctls הנובעים מגרסאות מינוריות של ליבת ברירת המחדל עבור
הפלטפורמה הזו. זה שימושי להפעלה על גרעינים פרוצים או עם מודולי ליבה
התומכים ב-ioctls לא סטנדרטיים, למשל. השתמש בזהירות. אם לא
להבין מה האפשרות הזו עושה אז כמעט בטוח שלא תזדקק לה. כַּיוֹם
גרסאות ידועות הן:

· bproc: תתמוך ב sys_broc שיחת מערכת ב-x86. זה מיועד להפעלה על BProc,
שהוא גרסה מינורית של לינוקס רגילה המשמשת לפעמים לבנייה
אשכולות.

· android-no-hw-tls: גרסאות מסוימות של אמולטור אנדרואיד עבור ARM אינן מספקות א
חומרה TLS (מצב שרשור מקומי) רושם, ו-Valgrind קורס בעת ההפעלה. להשתמש
גרסה זו לבחירת תמיכת תוכנה עבור TLS.

· android-gpu-sgx5xx: השתמש בזה כדי לתמוך בטיפול ב-ioctls קנייניים עבור
PowerVR SGX 5XX סדרת GPUs במכשירי אנדרואיד. אי בחירה בזה לא
לגרום לבעיות יציבות, אך עלול לגרום ל-Memcheck לדווח על שגיאות שווא לאחר ה
התוכנית מבצעת ioctls ספציפיים ל-GPU.

· android-gpu-adreno3xx: באופן דומה, השתמש בזה כדי לתמוך בטיפול בקניין
ioctls עבור סדרת ה-GPUs של Qualcomm Adreno 3XX במכשירי אנדרואיד.

--merge-recursive-frames= [בְּרִירַת מֶחדָל: 0]
כמה אלגוריתמים רקורסיביים, למשל יישומי עצים בינאריים מאוזנים, יוצרים
עקבות מחסנית רבים ושונים, כל אחד מכיל מחזורי שיחות. מחזור מוגדר כ
שני ערכי מונה תוכניות זהים המופרדים על ידי אפס או יותר מונה תוכניות אחר
ערכים. Valgrind עשוי אז להשתמש בזיכרון רב כדי לאחסן את כל עקבות הערימה הללו. זה
שימוש לקוי בזיכרון בהתחשב בעובדה שעקבות מחסניות כאלה מכילות לא מעניינות חוזרות ונשנות
שיחות רקורסיביות במקום מידע מעניין יותר כמו הפונקציה שיש
יזם את השיחה הרקורסיבית.

האפשרות --merge-recursive-frames= מורה לוואלגרינד לזהות ולמזג
מחזורי שיחה רקורסיביים בגודל של עד מסגרות. כאשר מחזור כזה הוא
זוהה, Valgrind מתעד את המחזור במעקב המחסנית כמונה תוכניות ייחודי.

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

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

--num-transtab-sectors= [בְּרִירַת מֶחדָל: 6 ל אנדרואיד פלטפורמות, 16 ל את כל אחרים]
Valgrind מתרגם ומכשיר את קוד המכונה של התוכנית שלך בחלקים קטנים
(בלוקים בסיסיים). התרגומים מאוחסנים במטמון תרגום מחולק
למספר מקטעים (מגזרים). אם המטמון מלא, הסקטור המכיל את
התרגומים העתיקים ביותר מתרוקנים ועושים שימוש חוזר. אם יש צורך שוב בתרגומים הישנים האלה,
Valgrind חייב לתרגם מחדש ולהכשיר מחדש את קוד המכונה המתאים, כלומר
יָקָר. אם ערכת העבודה של "ההוראות המבוצעות" של תוכנית גדולה, היא עולה
מספר המגזרים עשוי לשפר את הביצועים על ידי הפחתת מספר
יש צורך בתרגום מחדש. מגזרים מוקצים לפי דרישה. לאחר שהוקצה, מגזר יכול
לעולם לא ישתחרר, ותופס מקום ניכר, תלוי בכלי ובערך
of --avg-transtab-entry-size (כ-40 MB למגזר עבור Memcheck). השתמש באפשרות
--סטטיסטיקות=כן כדי לקבל מידע מדויק על הזיכרון המשמש את המגזר וה-
הקצאה ומיחזור של מגזרים.

--avg-transtab-entry-size= [בְּרִירַת מֶחדָל: 0, משמעות להשתמש כלי ובלבד בְּרִירַת מֶחדָל]
גודל ממוצע של בלוק בסיסי מתורגם. גודל ממוצע זה משמש למימד של
גודל של מגזר. כל כלי מספק ערך ברירת מחדל לשימוש. אם ערך ברירת המחדל הזה
קטן מדי, מגזרי התרגום יתמלאו מהר מדי. אם זה ברירת מחדל
הערך גדול מדי, חלק ניכר מזיכרון מגזר התרגום לא יהיה בשימוש.
שים לב שהגודל הממוצע של תרגום בלוק בסיסי תלוי בכלי ויכול
תלוי באפשרויות הכלים. לדוגמה, אפשרות memcheck --track-origins=כן עליות
הגודל של תרגומי הבלוק הבסיסיים. להשתמש --avg-transtab-entry-size כדי לכוון את
גודל הסקטורים, או כדי לצבור זיכרון או כדי למנוע יותר מדי תרגום מחדש.

--aspace-minaddr= [בְּרִירַת מֶחדָל: תלוי on מה היא פּלַטפוֹרמָה]
כדי למנוע התנגשויות פוטנציאליות עם מספר ספריות מערכת, Valgrind לא משתמש ב-
מרחב הכתובות למטה --aspace-minaddr ערך, לשמור אותו שמור במקרה של ספרייה
מבקש במיוחד זיכרון באזור זה. אז, מנחש ערך "פסימי" כלשהו
מאת Valgrind בהתאם לפלטפורמה. ב-Linux, כברירת מחדל, Valgrind נמנע משימוש ב-
64MB ראשונים גם אם בדרך כלל אין התנגשות באזור השלם הזה. אתה יכול להשתמש
האפשרות --aspace-minaddr כדי שהאפליקציה הרעבה לזיכרון שלך תפיק תועלת
יותר מהזיכרון הנמוך הזה. מצד שני, אם אתה נתקל בקונפליקט, עולה
ערך aspace-minaddr עשוי לפתור את זה. קונפליקטים יתבטאו בדרך כלל עם
כשלי mmap בטווח הנמוך של מרחב הכתובות. הכתובת שסופקה חייבת להיות עמוד
מיושר וחייב להיות שווה או גדול יותר ל-0x1000 (4KB). כדי למצוא את ערך ברירת המחדל שלך
פלטפורמה, עשה משהו כגון valgrind -d -d date 2>&1 | grep -i minaddr. ערכים
ידוע כי נמוך מ-0x10000 (64KB) יוצרים בעיות בהפצות מסוימות.

--valgrind-stacksize= [בְּרִירַת מֶחדָל: 1MB]
עבור כל חוט, Valgrind צריך מחסנית 'פרטית' משלו. גודל ברירת המחדל עבור אלה
ערימות הן במידה רבה, ולכן הן אמורות להספיק ברוב המקרים. במקרה של
הגודל קטן מדי, Valgrind יפגום. לפני התקלות, עשויה להיות אזהרה
מיוצר על ידי Valgrind כאשר מתקרבים לגבול.

השתמש באפשרות --valgrind-stacksize אם תופק אזהרה כזו (לא סבירה), או
Valgrind מת עקב הפרת פילוח. הפרות פילוח כאלה היו
ניתן לראות בעת פירוק סמלי C++ ענקיים.

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

--show-emwarns= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Valgrind ישדר אזהרות לגבי הדמיית המעבד שלו במקרים מסוימים.
אלה בדרך כלל לא מעניינים.

--require-text-symbol=:sonamepatt:fnnamepatt
כאשר אובייקט משותף שהסונאם שלו תואם sonamepatt נטען לתוך התהליך,
בדוק את כל סמלי הטקסט שהוא מייצא. אם אף אחד מאלה לא תואם fnnamepatt, הדפס
הודעת שגיאה ועזוב את הריצה. זה מאפשר להבטיח שהריצה כן
לא להמשיך אלא אם כן אובייקט משותף נתון מכיל שם פונקציה מסוים.

שניהם sonamepatt ו fnnamepatt ניתן לכתוב באמצעות הרגיל ? ו * תווים כלליים. ל
דוּגמָה: ":*libc.so*:foo?bar". אתה יכול להשתמש בתווים שאינם נקודתיים כדי להפריד
שני הדפוסים. חשוב רק שהדמות הראשונה והמפריד
אופי זהים. לדוגמה, ניתן לכתוב גם את הדוגמה לעיל
"Q*libc.so*Qfoo?bar". מרובות
--דרוש-טקסט-סמל דגלים מותרים, ובמקרה זה אובייקטים משותפים שנטענים
לתוך התהליך ייבדק מול כולם.

המטרה של זה היא לתמוך בשימוש אמין בספריות מסומנות. לדוגמה,
נניח שיש לנו גרסה של GCC libgomp.so אשר סומן עם
הערות לתמיכה בהלגרינד. קל מדי ומבלבל לטעון את הלא נכון,
ללא הערות libgomp.so לתוך האפליקציה. אז הרעיון הוא: הוסף סמל טקסט ב-
ספרייה מסומנת, למשל הערות_עבור_helgrind_3_6, ולאחר מכן לתת את הדגל
--require-text-symbol=:*libgomp*so*:annotated_for_helgrind_3_6 כך שמתי libgomp.so
נטען, Valgrind סורק את טבלת הסמלים שלו, ואם הסמל אינו קיים, הריצה כן
הופסק, במקום להמשיך בשקט עם הספרייה הלא מסומנת. שימו לב שאתם
צריך לשים את כל הדגל במירכאות כדי לעצור את התרחבות הפגזים * ו ?
תווים כלליים.

--soname-synonyms=syn1=דפוס1,syn2=דפוס2,...
כאשר ספרייה משותפת נטענת, Valgrind בודק פונקציות בספרייה
יש להחליף או לעטוף. לדוגמה, Memcheck מחליף את כל הקשור ל-malloc
פונקציות (malloc, free, calloc, ...) עם גרסאות משלה. תחליפים כאלה הם
נעשה כברירת מחדל רק בספריות משותפות שה-soname שלהן תואם ל-soname מוגדר מראש
דפוס (למשל libc.so* בלינוקס). כברירת מחדל, לא מתבצעת החלפה סטטית
ספרייה מקושרת או עבור ספריות חלופיות כגון tcmalloc. במקרים מסוימים, ה
תחליפים מאפשרים --soname-מילים נרדפות כדי לציין דפוס מילה נרדפת אחת נוספת, מתן
גמישות בהחלפה.

נכון לעכשיו, גמישות זו מותרת רק עבור הפונקציות הקשורות ל-malloc, באמצעות
המילה הנרדפת סומאלוק. מילה נרדפת זו ניתנת לשימוש עבור כל הכלים המבצעים החלפה סטנדרטית
של פונקציות הקשורות ל-malloc (למשל memcheck, massif, drd, helgrind, exp-dhat,
exp-sgcheck).

· ספריית malloc חלופית: כדי להחליף את הפונקציות הקשורות ל-malloc במקום חלופי
ספרייה עם soname mymalloclib.so, תן את האפשרות
--soname-synonyms=somalloc=mymalloclib.so. ניתן להשתמש בדפוס כדי להתאים מרובים
ספריות sonames. לדוגמה, --soname-synonyms=somalloc=*tcmalloc* יתאים
ה-soname של כל הגרסאות של ספריית tcmalloc (מקורי, ניפוי באגים, פרופיל, ...
גרסאות tcmalloc).

הערה: ניתן לאחזר את ה-soname של ספרייה משותפת של elf באמצעות ה-readelf
תוֹעֶלֶת.

· החלפות בספרייה מקושרת סטטית נעשים באמצעות ה- אף לא אחד דפוס.
לדוגמה, אם אתה מקשר עם libtcmalloc.a, memcheck יעבוד כמו שצריך כאשר אתה
לתת את האפשרות --soname-synonyms=somalloc=NONE. שים לב שדפוס NONE יעשה זאת
להתאים לקובץ ההפעלה הראשי ולכל ספרייה משותפת שאין לה soname.

· להריץ מבנה "ברירת מחדל" של Firefox עבור לינוקס, שבו JEMalloc מקושר ל-
קובץ הפעלה ראשי, שימוש --soname-synonyms=somalloc=NONE.

פיתרון VALGRIND אפשרויות

יש גם כמה אפשרויות לאיתור באגים של Valgrind עצמה. אתה לא צריך להשתמש בהם
בהתנהלות הרגילה של הדברים. אם ברצונך לראות את הרשימה, השתמש ב- ---help-debug אוֹפְּצִיָה.

MEMCHECK אפשרויות

--leak-check= [בְּרִירַת מֶחדָל: סיכום]
כאשר מופעל, חפש דליפות זיכרון כאשר תוכנית הלקוח מסתיימת. אם מוגדר ל
תקציר, זה אומר כמה דליפות התרחשו. אם מוגדר ל מלא or כן, כל דליפה בנפרד
יוצג בפירוט ו/או ייספר כשגיאה, כמפורט באפשרויות
--הצג-מיני-דליפות ו --שגיאות לסוגי דליפות.

--leak-resolution= [בְּרִירַת מֶחדָל: גָבוֹהַ]
כאשר מבצעים בדיקת דליפות, קובע עד כמה Memcheck מוכן לשקול אחרת
עקבות לאחור להיות זהות למטרות מיזוג דליפות מרובות ליחידה
דיווח על דליפה. כאשר מוגדר ל נמוך, רק שני הערכים הראשונים צריכים התאמה. מתי מד, ארבעה
הערכים צריכים להתאים. מתי גָבוֹהַ, כל הערכים צריכים להתאים.

עבור ניפוי דליפות הארדקור, אתה כנראה רוצה להשתמש ---leak-resolution=גבוהה יַחַד
עם --num-callers=40 או מספר כה גדול.

שים לב כי --רזולוציית דליפה ההגדרה אינה משפיעה על היכולת של Memcheck למצוא
דליפות. זה רק משנה את אופן הצגת התוצאות.

--show-leak-kinds= [בְּרִירַת מֶחדָל: ברור, אפשרי]
מציין את סוגי הדליפות שיוצגו ב-a מלא חיפוש דליפות, באחת מהדרכים הבאות:

· רשימה מופרדת בפסיקים של אחד או יותר מוחלט עקיף אפשרי נגיש.

· את כל כדי לציין את הסט המלא (כל סוגי הדליפות). זה שווה ערך ל
--show-leak-kinds=מוגדר, עקיף, אפשרי, ניתן להשגה.

· אף לא אחד עבור הסט הריק.

--errors-for-leak-kinds= [בְּרִירַת מֶחדָל: ברור, אפשרי]
מציין את סוגי הדליפות שייחשבו כשגיאות ב-a מלא חיפוש דליפות. ה is
מצוין בדומה ל --הצג-מיני-דליפות

--leak-check-heuristics= [בְּרִירַת מֶחדָל: את כל]
מציין את קבוצת ההיוריסטיקות לבדיקת דליפות שבהן יש להשתמש במהלך חיפושי דליפות. ה
היוריסטיקה קובעת אילו מצביעים פנימיים לבלוק גורמים לו להיחשב כאל
נגיש. הסט ההיוריסטי מצוין באחת מהדרכים הבאות:

· רשימה מופרדת בפסיקים של אחד או יותר stdstring אורך64 מערך חדש
ירושה מרובה.

· את כל כדי להפעיל את הסט השלם של היוריסטיות. זה שווה ערך ל
--leak-check-heuristics=stdstring,length64,newarray,multipleinheritance.

· אף לא אחד עבור הסט הריק.

שימו לב שהיוריסטיקות הללו תלויות בפריסה של האובייקטים המיוצרים על ידי ה-
מהדר C++. הם נבדקו עם כמה גרסאות gcc (למשל 4.4 ו-4.7). הֵם
ייתכן שלא יפעל כראוי עם מהדרים אחרים של C++.

--show-reachable= , --show-possibly-lost=
אפשרויות אלה מספקות דרך חלופית לציין את סוגי הדליפות שיוצגו:

· --show-reachable=לא --show-possibly-lost=כן שווה
--show-leak-kinds=מוגדר, אפשרי.

· --show-reachable=לא --show-possibly-lost=לא שווה
--show-leak-kinds=מוגדר.

· --show-reachable=כן שווה --show-leak-kinds=הכל.

שים לב כי --show-possibly-lost=לא אין לו השפעה אם --show-reachable=כן מוגדר.

--undef-value-errors= [בְּרִירַת מֶחדָל: כן]
שולט אם Memcheck מדווח על שימוש בשגיאות ערך לא מוגדר. הגדר את זה ל לא if
אתה לא רוצה לראות שגיאות ערך לא מוגדר. יש לזה גם תופעת לוואי של מהירות מופרזת
למעלה ממצ'ק משהו.

--track-origins= [בְּרִירַת מֶחדָל: לא]
שולט אם Memcheck עוקב אחר המקור של ערכים לא מאותחלים. כברירת מחדל, זה
לא, מה שאומר שלמרות שהוא יכול להגיד לך שערך לא מאותחל הוא
אם נעשה בו שימוש בצורה מסוכנת, זה לא יכול להגיד לך מהיכן הגיע הערך הלא התחלתי
מ. זה מקשה לעתים קרובות לאתר את בעיית השורש.

כאשר מוגדר ל כן, Memcheck עוקב אחר המקורות של כל הערכים הלא-מאתחלים.
לאחר מכן, כאשר מדווחת על שגיאת ערך לא מאותחל, Memcheck תנסה להציג את
מקור הערך. מקור יכול להיות אחד מארבעת המקומות הבאים: גוש ערימה,
הקצאת מחסנית, בקשת לקוח או מקורות אחרים שונים (למשל, קריאה אל
BRK).

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

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

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

שימו לב שהשילוב --track-origins=כן ו --undef-value-errors=לא is
שׁטוּתִי. Memcheck בודק ודוחה את השילוב הזה בעת ההפעלה.

--partial-loads-ok= [בְּרִירַת מֶחדָל: כן]
שולט כיצד Memcheck מטפל בעומסים מיושרים טבעיים של 32, 64, 128 ו-256 סיביות מ
כתובות שעבורן חלק מהבתים ניתנים להתייחסות ואחרים לא. מתי כן, כגון
עומסים אינם מייצרים שגיאת כתובת. במקום זאת, בתים טעונים שמקורם בלא חוקי
כתובות מסומנות כלא מאותחלות, ואלו המתאימות לכתובות חוקיות
מטופלים בדרך הרגילה.

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

שימו לב שקוד שמתנהג בצורה זו מפר את תקני ISO C/C++,
וצריך לראות בו שבור. אם זה אפשרי, יש לתקן קוד כזה.

---expensive-definedness-checks= [בְּרִירַת מֶחדָל: לא]
שולט אם Memcheck צריך להעסיק יותר מדויק אך גם יקר יותר (זמן
צורכים) אלגוריתמים בעת בדיקת הגדרתו של ערך. הגדרת ברירת המחדל היא
לא לעשות את זה וזה בדרך כלל מספיק. עם זאת, עבור קוד מותאם במיוחד
ולגרינד עשוי לפעמים להתלונן באופן שגוי. מעורר valgrind עם
--יוקר-הגדרות-בדיקות=כן עוזר אבל כרוך בעלות ביצועים. זמן ריצה
נצפתה השפלה של 25% אך העלות הנוספת תלויה רבות ב
יישום בהישג יד.

--keep-stacktraces=alloc|free|alloc-and-free|alloc-then-free|none [בְּרִירַת מֶחדָל:
להקצות וללא תשלום]
שולט אילו עקבות מחסנית לשמור עבור בלוקים שנעשו ב-malloc ו/או חופשיים.

עם הקצה-לאחר מכן-חינם, עקבות מחסנית נרשמת בזמן ההקצאה, והיא משויכת
עם הבלוק. כאשר הבלוק משוחרר, נרשם עקבות מחסנית שנייה, וזה
מחליף את מעקב מחסנית ההקצאה. כתוצאה מכך, כל שגיאות "שימוש לאחר חינם" הקשורות
לבלוק זה יכול להראות רק עקבות מחסנית עבור המקום שבו הבלוק שוחרר.

עם להקצות וללא תשלום, הן מעקבי ההקצאה והן מחסנית ההקצאה עבור הבלוק
מאוחסנים. לפיכך שגיאת "שימוש לאחר חינם" תציג את שניהם, מה שעלול לגרום לשגיאה
קל יותר לאבחן. לְעוּמַת הקצה-לאחר מכן-חינם, הגדרה זו גדלה מעט
השימוש בזיכרון של Valgrind בתור הבלוק מכיל שני הפניות במקום אחד.

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

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

שימו לב שברגע שנרשמת עקבות מחסנית, Valgrind שומר את עקבות הערימה בזיכרון
גם אם לא מתייחסים אליו בשום בלוק. תוכניות מסוימות (לדוגמה, רקורסיביות
אלגוריתמים) יכולים ליצור מספר עצום של עקבות מחסנית. אם Valgrind משתמש יותר מדי
זיכרון בנסיבות כאלה, תוכל לצמצם את הזיכרון הנדרש בעזרת האפשרויות
--keep-stacktracks ו/או באמצעות ערך קטן יותר עבור האופציה --מספר-מתקשרים.

--freelist-vol= [בְּרִירַת מֶחדָל: 20000000]
כאשר תוכנת הלקוח משחררת זיכרון באמצעות חופשי (ב-C) או מחק (C++), את הזיכרון הזה
אינו זמין באופן מיידי להקצאה מחדש. במקום זאת, הוא מסומן
בלתי נגיש וממוקם בתור של בלוקים משוחררים. המטרה היא לדחות כל עוד
אפשרי הנקודה שבה הזיכרון המשוחרר חוזר למחזור. זֶה
מגדיל את הסיכוי ש-Memcheck תוכל לזהות גישה לא חוקית לחסימות
לפרק זמן משמעותי לאחר שהם שוחררו.

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

--freelist-big-blocks= [בְּרִירַת מֶחדָל: 1000000]
בעת הפיכת בלוקים מהתור של בלוקים משוחררים לזמינים להקצאה מחדש,
Memcheck תחזיר בעדיפות את הבלוקים בגודל גדול או שווה לו
---freelist-big-blocks. זה מבטיח שחרור בלוקים גדולים (במיוחד שחרור
בלוקים גדולים מ --freelist-vol) אינו מוביל מיד למחזור חוזר של
כל (או הרבה) הבלוקים הקטנים ברשימה החינמית. במילים אחרות, אפשרות זו
מגדיל אפילו את הסבירות לגלות מצביעים משתלשלים עבור הבלוקים ה"קטנים".
כאשר בלוקים גדולים משתחררים.

הגדרת ערך 0 פירושה שכל הבלוקים מופצים מחדש בסדר FIFO.

--workaround-gcc296-bugs= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, נניח שקורא וכותב מרחק קטן מתחת למצביע המחסנית
נובעים מבאגים ב-GCC 2.96, ואינו מדווח עליהם. ה"מרחק הקטן" הוא 256
בתים כברירת מחדל. שים לב ש-GCC 2.96 הוא מהדר ברירת המחדל בכמה לינוקס עתיקים
הפצות (RedHat 7.X) ולכן ייתכן שיהיה עליך להשתמש באפשרות זו. אל תשתמש בו אם
אתה לא חייב, מכיוון שזה עלול לגרום להתעלמות מטעויות אמיתיות. אלטרנטיבה טובה יותר
הוא להשתמש ב-GCC עדכני יותר שבו הבאג הזה תוקן.

ייתכן שיהיה עליך להשתמש באפשרות זו גם בעת עבודה עם GCC 3.X או 4.X ב-32 סיביות
PowerPC Linux. הסיבה לכך היא ש-GCC מייצר קוד שמדי פעם ניגש למטה
מצביע המחסנית, במיוחד עבור המרות מנקודה צפה אל/ממספרים שלמים. זֶה
מפר את מפרט ה- PowerPC ELF של 32 סיביות, שאינו קובע
מיקומים מתחת למצביע המחסנית כדי להיות נגישים.

--show-mismatched-frees= [בְּרִירַת מֶחדָל: כן]
כאשר מופעל, Memcheck בודק שהקצאה של קוביות ערימה באמצעות פונקציה ש
תואם את פונקציית ההקצאה. כלומר, הוא מצפה חופשי שישמש להקצאה
בלוקים שהוקצו על ידי malloc, להסיר עבור בלוקים שהוקצו על ידי חדש, ו לִמְחוֹק[] ל
בלוקים שהוקצו על ידי חָדָשׁ[]. אם מזוהה אי התאמה, מדווחת שגיאה. זה ב
כללי חשוב כי בסביבות מסוימות, שחרור עם פונקציה שאינה תואמת
יכול לגרום לקריסות.

עם זאת, יש תרחיש שבו אי התאמה כזו לא ניתן להימנע. זה כאשר ה
המשתמש מספק יישומים של חדש/חָדָשׁ[] השיחה ההיא malloc של להסיר/לִמְחוֹק[]
השיחה ההיא חופשי, והפונקציות הללו משובצות בצורה אסימטרית. למשל, דמיינו
זֶה לִמְחוֹק[] מוטבע אבל חָדָשׁ[] לא. התוצאה היא שמצ'ק "רואה" הכל
לִמְחוֹק[] שיחות כשיחות ישירות אל חופשי, גם כאשר מקור התוכנית מכיל no
שיחות לא תואמות.

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

--ignore-ranges=0xPP-0xQQ[,0xRR-0xSS]
כל הטווחים המפורטים באפשרות זו (וניתן לציין מספר טווחים, מופרדים על ידי
פסיקים) יתעלמו מבדיקת יכולת ההתייחסות של Memcheck.

--malloc-fill=
ממלא בלוקים שהוקצו על ידי malloc, חדש וכו', אך לא על ידי calloc, עם המפורט
בייט. זה יכול להיות שימושי כאשר מנסים לנער בעיות של שחיתות זיכרון לא ברורים.
השטח המוקצה עדיין נחשב על ידי Memcheck כלא מוגדר - אפשרות זו בלבד
משפיע על תוכנו. ציין זאת --malloc-fill אינו משפיע על גוש זיכרון כאשר
הוא משמש כארגומנט לבקשות הלקוח VALGRIND_MEMPOOL_ALLOC או
VALGRIND_MALLOCLIKE_BLOCK.

--free-fill=
ממלא בלוקים ששוחררו על ידי free, delete וכו', בערך הבתים שצוין. זה יכול להיות
שימושי כאשר מנסים לנער בעיות של שחיתות זיכרון לא ברורים. האזור המשוחרר הוא
עדיין נחשבת על ידי Memcheck כלא חוקית לגישה -- אפשרות זו משפיעה רק על הגישה שלה
תוכן. ציין זאת --מילוי חינם אינו משפיע על גוש זיכרון כאשר הוא משמש כ
ארגומנט ללקוח בקשות VALGRIND_MEMPOOL_FREE או VALGRIND_FREELIKE_BLOCK.

CACHEGRIND אפשרויות

--I1= , , גודל>
ציין את הגודל, האסוציאטיביות וגודל השורה של מטמון ההוראות ברמה 1.

--D1= , , גודל>
ציין את הגודל, האסוציאטיביות וגודל השורה של מטמון הנתונים ברמה 1.

--LL= , , גודל>
ציין את הגודל, האסוציאטיביות וגודל השורה של המטמון ברמה האחרונה.

--cache-sim=לא|כן [כן]
מאפשר או משבית את איסוף הגישה למטמון וספירת החמצות.

--branch-sim=לא|כן [לא]
מאפשר או משבית איסוף של הוראות סניף וספירות חיזוי שגוי. על ידי
ברירת המחדל זה מושבת מכיוון שהוא מאט את קצב ה-Cachegrind בכ-25%. ציין זאת
אתה לא יכול לציין --cache-sim=לא ו --branch-sim=לא יחד, כי זה יעזוב
Cachegrind ללא מידע לאסוף.

--cachegrind-out-file=
כתוב את נתוני הפרופיל לקובץ ולא לקובץ הפלט המוגדר כברירת מחדל,
cachegrind.out. . ה %p ו %q ניתן להשתמש במפרטי פורמטים כדי להטמיע את התהליך
ID ו/או התוכן של משתנה סביבה בשם, כפי שקורה ב-
אפשרות ליבה --קובץ לוג.

CALLGRIND אפשרויות

--callgrind-out-file=
כתוב את נתוני הפרופיל לקובץ ולא לקובץ הפלט המוגדר כברירת מחדל,
callgrind.out. . ה %p ו %q ניתן להשתמש במפרטי פורמטים כדי להטמיע את התהליך
ID ו/או התוכן של משתנה סביבה בשם, כפי שקורה ב-
אפשרות ליבה --קובץ לוג. כאשר מתבצעות מספר dumps, שם הקובץ משתנה
נוסף; ראה למטה.

--שורת dump= [בְּרִירַת מֶחדָל: כן]
זה מציין שספירת אירועים צריכה להתבצע בפירוט קו המקור.
זה מאפשר הערת מקור עבור מקורות אשר מורכבים עם מידע על ניפוי באגים
(-g).

--dump-instr= [בְּרִירַת מֶחדָל: לא]
זה מציין שספירת אירועים צריכה להתבצע בפירוט לפי הוראה.
זה מאפשר הערת קוד הרכבה. כרגע ניתן להציג את התוצאות בלבד
מאת KCachegrind.

--compress-strings= [בְּרִירַת מֶחדָל: כן]
אפשרות זו משפיעה על פורמט הפלט של נתוני הפרופיל. זה מפרט אם
מחרוזות (שמות קבצים ופונקציות) צריכות להיות מזוהות באמצעות מספרים. זה מכווץ את
קובץ, אבל מקשה על בני אדם לקרוא (מה שלא מומלץ בשום קובץ
מקרה).

--compress-pos= [בְּרִירַת מֶחדָל: כן]
אפשרות זו משפיעה על פורמט הפלט של נתוני הפרופיל. זה מפרט אם
מיקומים מספריים תמיד מצוינים כערכים מוחלטים או מותר להם להיות
ביחס למספרים הקודמים. זה מכווץ את גודל הקובץ.

--combine-dumps= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, כאשר יש להפיק חלקי נתוני פרופיל מרובים, חלקים אלו
מצורף לאותו קובץ פלט. לא מומלץ.

--dump-every-bb= [בְּרִירַת מֶחדָל: 0, לעולם לא]
זרוק נתוני פרופיל כל לספור בלוקים בסיסיים. האם יש צורך במזבלה רק בודקים
כאשר המתזמן הפנימי של Valgrind מופעל. לכן, ההגדרה המינימלית שימושית היא
בערך 100000. הספירה היא ערך של 64 סיביות כדי לאפשר תקופות dump ארוכות.

--dump-before=
לזרוק בעת הכניסה פונקציה.

--אפס-לפני=
אפס את כל העלויות בעת הכניסה פונקציה.

--dump-after=
לזרוק כשיוצאים פונקציה.

--instr-atstart= [בְּרִירַת מֶחדָל: כן]
ציין אם ברצונך ש-Callgrind יתחיל סימולציה ויצירת פרופילים מההתחלה של
התכנית. כאשר מוגדר לא, Callgrind לא יוכל לאסוף מידע כלשהו,
כולל שיחות, אבל תהיה לו האטה לכל היותר בסביבות 4, שזה המינימום
ולגרינד מעל הראש. ניתן להפעיל מכשור באופן אינטראקטיבי באמצעות callgrind_control
-אני על.

שים לב שגרף השיחות המתקבל כנראה לא יכיל ראשי, אבל יהיה
מכילים את כל הפונקציות שבוצעו לאחר הפעלת המכשור. מִכשׁוּר
יכול גם להפעיל/להשבית באופן תכנותי. ראה את הקובץ Callgrind include callgrind.h
עבור המאקרו עליך להשתמש בקוד המקור שלך.

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

--collect-atstart= [בְּרִירַת מֶחדָל: כן]
ציין אם איסוף אירועים מופעל בתחילת הפעלת הפרופיל.

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

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

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

ניתן להשתמש באפשרות השנייה אם חלק התוכנית שברצונך ליצור פרופיל נקרא רבים
פִּי. אפשרות 1, כלומר ליצור הרבה מזבלות זה לא מעשי כאן.

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

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

--toggle-collect=
החלף איסוף בכניסה/יציאה של פונקציה.

--איסוף-קפיצות= [בְּרִירַת מֶחדָל: לא]
זה מציין אם יש לאסוף מידע עבור קפיצות (מותנה). כפי ש
למעלה, callgrind_annotate כרגע לא יכול להראות לך את הנתונים. אתה חייב להשתמש
KCachegrind כדי לקבל חיצי קפיצה בקוד המוער.

--collect-systime= [בְּרִירַת מֶחדָל: לא]
זה מציין אם יש לאסוף מידע עבור זמני שיחות מערכת.

--איסוף-אוטובוס= [בְּרִירַת מֶחדָל: לא]
זה מציין אם יש לאסוף את מספר אירועי האוטובוס העולמיים שבוצעו.
סוג האירוע "Ge" משמש עבור אירועים אלה.

--cache-sim= [בְּרִירַת מֶחדָל: לא]
ציין אם אתה רוצה לעשות הדמיית מטמון מלאה. כברירת מחדל, רק הוראות נקראות
כניסות ייספרו ("Ir"). עם הדמיית מטמון, מונים אירועים נוספים
מופעל: מטמון חסר בקריאה של הוראות ("I1mr"/"ILmr"), גישה לקריאת נתונים ("Dr")
ופספוסי מטמון קשורים ("D1mr"/"DLmr"), גישה לכתיבה לנתונים ("Dw") ומטמון קשור
פספוסים ("D1mw"/"DLmw"). למידע נוסף, ראה Cachegrind: מטמון וסניף-
פרופיל חיזוי.

--branch-sim= [בְּרִירַת מֶחדָל: לא]
ציין אם אתה רוצה לעשות סימולציית חיזוי ענפים. דלפקי אירועים נוספים הם
מופעל: מספר ענפים מותנים שבוצעו והחמצות מנבאים קשורות
("Bc"/"Bcm"), בוצעו קפיצות עקיפות והחמצות קשורות של מנבא כתובת הקפיצה
("בי"/"בים").

הלגרינד אפשרויות

--free-is-write=לא|כן [בְּרִירַת מֶחדָל: לא]
כאשר מופעל (לא ברירת המחדל), Helgrind מתייחס לשחרור זיכרון ערימה כאילו
הזיכרון נכתב מיד לפני החופש. זה חושף גזעים שבהם נמצא הזיכרון
מוזכר על ידי שרשור אחד, ומשוחרר על ידי אחר, אבל אין אפשרות לצפייה
אירוע סנכרון כדי להבטיח שההפניה מתרחשת לפני החופש.

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

--track-lockorders=לא|כן [בְּרִירַת מֶחדָל: כן]
כאשר מופעל (ברירת המחדל), Helgrind מבצע בדיקת עקביות של סדר הנעילה. ל
כמה תוכניות באגי, המספר הגדול של שגיאות הזמנת נעילה שדווחו יכול להפוך
מעצבן, במיוחד אם אתה מעוניין רק בשגיאות גזע. אתה יכול לכן
זה מועיל להשבית את בדיקת סדר הנעילה.

--history-level=none|בערך|מלא [בְּרִירַת מֶחדָל: מלא]
--history-level=מלא (ברירת המחדל) גורמת להלגרינד לאסוף מספיק מידע על
גישה "ישנה" שהיא יכולה לייצר שני עקבות מחסנית בדוח מרוץ - שניהם הערימה
מעקב עבור הגישה הנוכחית, והמעקב עבור הגישה הישנה, ​​המתנגשת. ל
הגבלת שימוש בזיכרון, עקבות מחסנית גישה "ישנות" מוגבלות ל-8 ערכים לכל היותר,
אפילו --מספר-מתקשרים הערך גדול יותר.

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

--history-level=אין היא הקיצוניות ההפוכה. זה גורם להלגרינד לא לאסוף אף אחד
מידע על גישה קודמת. זה יכול להיות מהיר יותר מ
--history-level=מלא.

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

--conflict-cache-size=N [בְּרִירַת מֶחדָל: 1000000]
לדגל זה יש השפעה רק ב --history-level=מלא.

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

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

הערך המינימלי הוא 10,000 והמקסימום הוא 30,000,000 (פי שלושים מברירת המחדל
ערך). הגדלת הערך ב-1 מגדילה מאוד את דרישת הזיכרון של Helgrind
בערך 100 בתים, כך שהערך המקסימלי יאכל בקלות שלושה גיגה-בייט נוספים בערך
של זיכרון.

--check-stack-refs=לא|כן [בְּרִירַת מֶחדָל: כן]
כברירת מחדל, Helgrind בודק את כל הגישה לזיכרון הנתונים שבוצעה על ידי התוכנית שלך. הדגל הזה
מאפשר לך לדלג על בדיקת גישה לערימות שרשורים (משתנים מקומיים). זה יכול
לשפר את הביצועים, אבל בא במחיר של מירוצים חסרים על נתונים שהוקצו מחסנית.

--ignore-thread-creation= [בְּרִירַת מֶחדָל: לא]
קובע אם יש להתעלם מכל הפעילויות במהלך יצירת השרשור. כברירת מחדל
מופעל רק ב- Solaris. Solaris מספקת תפוקה גבוהה יותר, מקביליות ו
מדרגיות ממערכות הפעלה אחרות, במחיר של נעילה עדינה יותר
פעילות. זה אומר למשל שכאשר נוצר שרשור תחת glibc, רק אחד
מנעול גדול משמש לכל הגדרות החוט. Solaris libc משתמש במספר מנעולים עדינים
וחוט היוצר חוזר לפעילותו בהקדם האפשרי, עוזב למשל
רצף הגדרות מחסנית ו-TLS לשרשור שנוצר. המצב הזה מבלבל את הלגרינד
מכיוון שהוא מניח שיש איזשהו סדר שווא בין הבורא לנברא
פְּתִיל; ולכן סוגים רבים של תנאי מרוץ ביישום לא יהיו
דיווח. כדי למנוע הזמנה כוזבת כזו, אפשרות שורת פקודה זו מוגדרת ל-yes על ידי
ברירת מחדל ב- Solaris. לכן מתעלמים מכל הפעילות (עומסים, חנויות, בקשות של לקוחות).
בְּמַהֲלָך:

· pthread_create() קריאה בשרשור היוצר

· שלב יצירת השרשור (הגדרת מחסנית ו-TLS) בשרשור שנוצר

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

DRD אפשרויות

--check-stack-var= [בְּרִירַת מֶחדָל: לא]
שולט אם DRD מזהה מירוצי נתונים על משתני מחסנית. אימות משתני מחסנית
מושבת כברירת מחדל מכיוון שרוב התוכניות אינן חולקות משתני מחסנית
חוטים.

--exclusive-threshold= [בְּרִירַת מֶחדָל: כבוי]
הדפס הודעת שגיאה אם ​​כל נעילת mutex או סופר הוחזקה יותר מהזמן
שצוין באלפיות שניות. אפשרות זו מאפשרת זיהוי של עימות מנעול.

--join-list-vol= [בְּרִירַת מֶחדָל: 10]
מירוצי נתונים המתרחשים בין הצהרה בסוף שרשור אחד לשרשור אחר
ניתן לפספס אם מידע גישה לזיכרון נמחק מיד לאחר שרשור יש
הצטרפו. אפשרות זו מאפשרת לציין עבור כמה זיכרון שרשורים שהצטרפו
יש לשמור מידע גישה.

--המירוץ הראשון בלבד= [בְּרִירַת מֶחדָל: לא]
האם לדווח רק על מירוץ הנתונים הראשון שזוהה במיקום זיכרון
או כל מירוצים הנתונים שזוהו במיקום זיכרון.

--free-is-write= [בְּרִירַת מֶחדָל: לא]
האם לדווח על מירוצים בין גישה לזיכרון לשחרור זיכרון. מאפשר זאת
האפשרות עלולה לגרום ל-DRD לפעול מעט יותר לאט. הערות:

· אל תפעיל אפשרות זו בעת שימוש במקצי זיכרון מותאמים אישית המשתמשים ב-
VG_USERREQ__MALLOCLIKE_BLOCK ו-VG_USERREQ__FREELIKE_BLOCK כי זה
לגרום לתוצאות חיוביות שגויות.

· אל תפעיל את האפשרות הזו בעת שימוש באובייקטים שנספרו הפניות כי זה יעשה זאת
לגרום לתוצאות חיוביות שגויות, גם כאשר הקוד הזה סומן כראוי
ANNOTATE_HAPPENS_BEFORE ו-ANNOTE_HAPPENS_AFTER. ראה למשל את הפלט של
הפקודה הבאה לדוגמא: valgrind --tool=drd --free-is-write=yes
drd/tests/annotate_smart_pointer.

--report-signal-unlocked= [בְּרִירַת מֶחדָל: כן]
האם לדווח על שיחות pthread_cond_signal ו pthread_cond_broadcast שם
mutex הקשור לאות דרך pthread_cond_wait or
pthread_cond_timed_waitאינו נעול בזמן שליחת האות. שולח אות
ללא החזקת מנעול על mutex המשויך היא שגיאת תכנות נפוצה שיכולה
לגרום לתנאי גזע עדינים והתנהגות בלתי צפויה. יש כמה לא שכיחים
דפוסי סנכרון לעומת זאת היכן שבטוח לשלוח אות מבלי להחזיק את a
לנעול את המוטקס המשויך.

--קטע-מיזוג= [בְּרִירַת מֶחדָל: כן]
שולט במיזוג פלחים. מיזוג פלחים הוא אלגוריתם להגבלת השימוש בזיכרון של
אלגוריתם זיהוי מירוץ נתונים. השבתת מיזוג פלחים עשויה לשפר את הדיוק של
מה שנקרא 'מקטעים אחרים' המוצגים בדוחות המירוץ אך יכולים גם לעורר יציאה
של שגיאת זיכרון.

--קטע-מיזוג-מרווח= [בְּרִירַת מֶחדָל: 10]
בצע מיזוג פלחים רק לאחר שבוצעו מספר הפלחים החדשים שצוין
נוצר. זוהי אפשרות תצורה מתקדמת המאפשרת לבחור אם כן
צמצם למינימום את השימוש בזיכרון של DRD על ידי בחירת ערך נמוך או כדי לאפשר ל-DRD לפעול מהר יותר
בחירה בערך קצת יותר גבוה. הערך האופטימלי עבור פרמטר זה תלוי ב-
תוכנית בניתוח. ערך ברירת המחדל עובד היטב עבור רוב התוכניות.

--shared-threshold= [בְּרִירַת מֶחדָל: כבוי]
הדפס הודעת שגיאה אם ​​נעילת קורא הוחזקה יותר מהזמן שצוין
(במילישניות). אפשרות זו מאפשרת זיהוי של עימות מנעול.

--show-confl-seg= [בְּרִירַת מֶחדָל: כן]
הצג פלחים סותרים בדוחות הגזע. מכיוון שמידע זה יכול לעזור למצוא את
גורם למירוץ נתונים, אפשרות זו מופעלת כברירת מחדל. השבתת אפשרות זו הופכת
הפלט של DRD קומפקטי יותר.

--show-stack-usage= [בְּרִירַת מֶחדָל: לא]
שימוש בערימה בהדפסה בזמן יציאת השרשור. כאשר תוכנית יוצרת מספר רב של
זה הופך להיות חשוב להגביל את כמות הזיכרון הווירטואלי שהוקצה עבורו
ערימות חוטים. אפשרות זו מאפשרת לראות כמה זיכרון מחסנית היה
בשימוש על ידי כל שרשור של תוכנית הלקוח. הערה: כלי ה-DRD עצמו מקצה חלק
נתונים זמניים בערימת פתיל הלקוח. המקום הדרוש לנתונים זמניים אלה
חייב להיות מוקצה על ידי תוכנית הלקוח כאשר היא מקצה זיכרון מחסנית, אבל לא
נכלל בשימוש בערימה שדווח על ידי DRD.

--ignore-thread-creation= [בְּרִירַת מֶחדָל: לא]
קובע אם יש להתעלם מכל הפעילויות במהלך יצירת השרשור. כברירת מחדל
מופעל רק ב- Solaris. Solaris מספקת תפוקה גבוהה יותר, מקביליות ו
מדרגיות ממערכות הפעלה אחרות, במחיר של נעילה עדינה יותר
פעילות. זה אומר למשל שכאשר נוצר שרשור תחת glibc, רק אחד
מנעול גדול משמש לכל הגדרות החוט. Solaris libc משתמש במספר מנעולים עדינים
וחוט היוצר חוזר לפעילותו בהקדם האפשרי, עוזב למשל
רצף הגדרות מחסנית ו-TLS לשרשור שנוצר. מצב זה מבלבל את DRD כפי שהוא
מניח שיש איזשהו סדר שווא בין היוצר לחוט שנוצר; ו
לכן סוגים רבים של תנאי מרוץ באפליקציה לא ידווחו. ל
למנוע סדר כוזב כזה, אפשרות שורת פקודה זו מוגדרת ל-yes כברירת מחדל
סולאריס. לכן מתעלמים מכל הפעילות (עומסים, חנויות, בקשות לקוחות) במהלך:

· pthread_create() קריאה בשרשור היוצר

· שלב יצירת השרשור (הגדרת מחסנית ו-TLS) בשרשור שנוצר

--trace-addr= [בְּרִירַת מֶחדָל: אף אחד]
עקוב אחר כל פעילות הטעינה והאחסון עבור הכתובת שצוינה. אפשרות זו עשויה להיות
צוין יותר מפעם אחת.

--ptrace-addr= [בְּרִירַת מֶחדָל: אף אחד]
עקבו אחר כל פעילות הטעינה והאחסון עבור הכתובת שצוינה והמשיכו לעשות זאת אפילו
לאחר שהזיכרון בכתובת זו שוחרר והוקצו מחדש.

--trace-alloc= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל ההקצאות וההקצאות הזיכרון. עשוי לייצר כמות עצומה של תפוקה.

--trace-barrier= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל פעילות המחסומים.

--trace-cond= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל פעילות משתני התנאים.

--trace-fork-join= [בְּרִירַת מֶחדָל: לא]
עקוב אחר כל יצירת השרשור וכל אירועי סיום השרשור.

--trace-hb= [בְּרִירַת מֶחדָל: לא]
עקבו אחר ביצוע ה-ANNOTATE_HAPPENS_BEFORE(), ANNOTATE_HAPPENS_AFTER() ו-
בקשות לקוח ANNOTATE_HAPPENS_DONE().

--trace-mutex= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל פעילות המוטקס.

--trace-rwlock= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל פעילות נעילת קורא-סופר.

--trace-semaphore= [בְּרִירַת מֶחדָל: לא]
עקבו אחר כל פעילות הסמפור.

מִקשֵׁה הָרִים אפשרויות

--ערמה= [בְּרִירַת מֶחדָל: כן]
מציין אם יש לבצע פרופיל ערימה.

--heap-admin= [בְּרִירַת מֶחדָל: 8]
אם פרופיל ערימה מופעל, נותן את מספר הבתים הניהוליים לכל בלוק
להשתמש. זו צריכה להיות אומדן של הממוצע, מכיוון שהוא עשוי להשתנות. לדוגמה, ה
הקצאה בשימוש על ידי glibc בלינוקס דורש איפשהו בין 4 ל-15 בתים לכל בלוק,
בהתאם לגורמים שונים. מקצה זה דורש גם שטח ניהול עבור פנוי
בלוקים, אבל Massif לא יכול להסביר זאת.

--ערימות= [בְּרִירַת מֶחדָל: לא]
מציין אם יש לבצע פרופיל מחסנית. אפשרות זו מאטה את Massif
מאוד, ולכן כבוי כברירת מחדל. שימו לב שמאסיף מניח שלמחסנית הראשית יש
מידה אפס בעת ההפעלה. זה לא נכון, אבל לעשות אחרת בצורה מדויקת זה קשה.
יתר על כן, התחלה מאפס מעידה טוב יותר על גודל החלק של המחסנית הראשית
שלתוכנת משתמש יש למעשה שליטה.

--pages-as-heap= [בְּרִירַת מֶחדָל: לא]
אומר ל-Massif לעשות פרופיל בזיכרון ברמת העמוד ולא בחסימה של malloc
רָמָה. ראה לעיל לפרטים.

--עומק= [בְּרִירַת מֶחדָל: 30]
עומק מרבי של עצי ההקצאה שנרשמו עבור צילומי מצב מפורטים. מגדילים אותו
יגרום ל- Massif לרוץ קצת יותר לאט, להשתמש ביותר זיכרון ולייצר פלט גדול יותר
קבצים.

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

שימו לב שהפונקציה בעלת השם תטופל בצורה זו רק אם היא הערך העליון ב-a
מעקב מחסנית, או ממש מתחת לפונקציה אחרת שטופלה כך. למשל, אם יש לך
תפקוד malloc1 שעוטף malloc, ו malloc2 שעוטף malloc1, רק מפרט
--alloc-fn=malloc2 לא תהיה השפעה. אתה צריך לפרט --alloc-fn=malloc1 as
נו. זה קצת לא נוח, אבל הסיבה היא שבדיקת הקצאה
הפונקציות איטיות, וזה חוסך הרבה זמן אם Massif יכול להפסיק להסתכל דרך
ערימת ערכים של מעקב ברגע שהוא מוצא אחד שאינו תואם במקום שצריך
המשך דרך כל הערכים.

שים לב ששמות C++ מסולקים. שימו לב גם ששמות C++ עמוסים חייבים להיכתב
במלואו. ייתכן שיהיה צורך במרכאות בודדות כדי למנוע מהקליפה לפרק אותן.
לדוגמה:

--alloc-fn='operator new(unsigned, std::nothrow_t const&)'

--ignore-fn=
כל הקצאת ערימה ישירה (כלומר שיחה אל malloc, חדש, וכו', או קריאה לפונקציה
שמו על ידי א --alloc-fn option) שמתרחשת בפונקציה שצוינה על ידי אפשרות זו
להתעלם. זה שימושי בעיקר למטרות בדיקה. ניתן לציין אפשרות זו
מספר פעמים בשורת הפקודה, לשם מספר פונקציות.

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

הכללים לכתיבת שמות פונקציות C++ זהים לזה של --alloc-fn מֵעַל.

--threshold= [בְּרִירַת מֶחדָל: 1.0]
סף המשמעות להקצאות ערימה, כאחוז מגודל הזיכרון הכולל.
ערכים של עץ ההקצאה המהווים פחות מזה יצטברו. ציין זאת
יש לציין זאת במקביל לאפשרות של ms_print באותו שם.

--שיא-אי דיוק= [בְּרִירַת מֶחדָל: 1.0]
Massif אינו רושם בהכרח את שיא הקצאת הזיכרון הגלובלי בפועל; על ידי
ברירת המחדל היא רושמת שיא רק כאשר גודל הקצאת הזיכרון הגלובלי עולה על
השיא הקודם ב-1.0% לפחות. הסיבה לכך היא שיכולות להיות הקצאות מקומיות רבות
שיאים לאורך הדרך, וביצוע תמונת מצב מפורטת עבור כל אחד יהיה יקר
ובזבזני, שכן כולם פרט לאחד יושלכו מאוחר יותר. חוסר דיוק זה יכול להיות
השתנה (אפילו ל-0.0%) באמצעות אפשרות זו, אך Massif יפעל לאט יותר באופן דרסטי
מספר מתקרב לאפס.

--יחידת זמן= [בְּרִירַת מֶחדָל: i]
יחידת הזמן המשמשת ליצירת הפרופיל. ישנן שלוש אפשרויות: הוראות
הוצא להורג (i), וזה טוב לרוב המקרים; זמן אמיתי (שעון קיר) (ms, כלומר
אלפיות השנייה), וזה לפעמים שימושי; ובייטים שהוקצו/מבוטלים בערימה
ו/או מחסנית (B), אשר שימושית עבור תוכניות קצרות מאוד, ולבדיקות
למטרות, מכיוון שהוא ניתן לשחזור ביותר במכונות שונות.

--detailed-freq= [בְּרִירַת מֶחדָל: 10]
תדירות צילומי מצב מפורטים. עם --detailed-freq=1, כל תמונת מצב מפורטת.

--max-snapshots= [בְּרִירַת מֶחדָל: 100]
המספר המרבי של צילומי מצב שהוקלטו. אם מוגדר ל-N, עבור כל התוכניות למעט מאוד
בטווחים קצרים, המספר הסופי של צילומי מצב יהיה בין N/2 ל-N.

--massif-out-file= [בְּרִירַת מֶחדָל: massif.out.%p]
כתוב את נתוני הפרופיל לקובץ ולא לקובץ הפלט המוגדר כברירת מחדל,
massif.out. . ה %p ו %q ניתן להשתמש במפרטי פורמטים כדי להטמיע את מזהה התהליך
ו/או התוכן של משתנה סביבה בשם, כפי שקורה ב-
אפשרות ליבה --קובץ לוג.

SGCHECK אפשרויות

אין כרגע אפשרויות שורת פקודה ספציפיות ל-SGCheck.

BBV אפשרויות

--bb-out-file= [בְּרִירַת מֶחדָל: bb.out.%p]
אפשרות זו בוחרת את השם של קובץ וקטור הבלוק הבסיסי. ה %p ו %q פוּרמָט
ניתן להשתמש במפרטים כדי להטמיע את מזהה התהליך ו/או את התוכן של סביבה
משתנה בשם, כמו במקרה של אפשרות הליבה --קובץ לוג.

--pc-out-file= [בְּרִירַת מֶחדָל: pc.out.%p]
אפשרות זו בוחרת את שם קובץ ה-PC. קובץ זה מכיל כתובות נגד תוכניות
ומידע על שם פונקציה עבור הבלוקים הבסיסיים השונים. זה יכול לשמש יחד
עם קובץ וקטור הבלוק הבסיסי להרצה קדימה באמצעות שמות פונקציות במקום רק
ההוראה סופרת. ה %p ו %q ניתן להשתמש במפרטי פורמטים כדי להטמיע את התהליך
ID ו/או התוכן של משתנה סביבה בשם, כפי שקורה ב-
אפשרות ליבה --קובץ לוג.

--interval-size= [בְּרִירַת מֶחדָל: 100000000]
אפשרות זו בוחרת את גודל המרווח לשימוש. ברירת המחדל היא 100 מיליון
הוראות, שהוא ערך נפוץ. ניתן להשתמש בגדלים אחרים; קטן יותר
מרווחים יכולים לעזור לתוכניות עם שלבים עדינים יותר. עם זאת גודל מרווח קטן יותר
יכול להוביל לבעיות דיוק עקב השפעות חימום (בעת העברה מהירה קדימה של השונות
מאפיינים ארכיטקטוניים לא יהיו מאתחלים, וזה ייקח מספר מסוים של
הוראות לפני שהם "מתחממים" למדינה סימולציה מלאה תהיה בלי
ההילוך המהיר. גדלי מרווחים גדולים נוטים להפחית זאת.)

--instr-count-only [בְּרִירַת מֶחדָל: לא]
אפשרות זו אומרת לכלי להציג רק סיכומי ספירת הוראות, ולא
ליצור את קובץ הווקטור הבסיסי בפועל של הבלוק. זה שימושי עבור איתור באגים, ועבור
איסוף מידע על ספירת הוראות מבלי ליצור את וקטור הבלוק הבסיסי הגדול
קבצים.

מְשָׁרֵת אפשרויות

--בסיסי-ספירות= [בְּרִירַת מֶחדָל: כן]
כאשר מופעל, Lackey מדפיס את הנתונים הסטטיסטיים והמידע הבאים על
ביצוע תוכנית הלקוח:

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

2. מספר הענפים המותנים שנתקלו ומספרם ושיעורם
אלה שנלקחו.

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

4. מספר הוראות האורח (x86, amd64, ppc וכו') והצהרות IR
יצא לפועל. IR הוא ייצוג הביניים דמוי RISC של Valgrind באמצעותו כל
מכשור נעשה.

5. יחסים בין חלק מהספירות הללו.

6. קוד היציאה של תוכנית הלקוח.

--ספירות מפורטות= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Lackey מדפיס טבלה המכילה ספירות של עומסים, חנויות ו-ALU
פעולות, המובדלות לפי סוגי ה-IR שלהן. סוגי ה-IR מזוהים לפי ה-IR שלהם
שם ("I1", "I8", ... "I128", "F32", "F64" ו-"V128").

--trace-mem= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Lackey מדפיס את הגודל והכתובת של כמעט כל גישה לזיכרון שנעשתה על ידי
התכנית. ראה את ההערות בחלק העליון של הקובץ lackey/lk_main.c לפרטים
על פורמט הפלט, איך הוא עובד ואי דיוקים במעקב הכתובות. הערה
שהאופציה הזו מייצרת כמויות אדירות של תפוקה.

--trace-superblocks= [בְּרִירַת מֶחדָל: לא]
כאשר מופעל, Lackey מדפיס את הכתובת של כל סופר בלוק (ערך בודד,
יציאה מרובה, גוש קוד ליניארי) המבוצע על ידי התוכנית. זה בעיקר של
עניין למפתחי Valgrind. ראה את ההערות בראש הקובץ
lackey/lk_main.c לפרטים על פורמט הפלט. שימו לב שאופציה זו מייצרת
כמויות גדולות של תפוקה.

--fnname= [בְּרִירַת מֶחדָל: רָאשִׁי]
משנה את הפונקציה שעבורה נספרים שיחות מתי --בסיסי-ספירות=כן מוגדר.

השתמש ב-valgrind.bin באינטרנט באמצעות שירותי onworks.net