memusage - מקוון בענן

תָכְנִית:

שֵׁם

memusage - פרופיל שימוש בזיכרון של תוכנית

תַקצִיר

מזכרות [אוֹפְּצִיָה] ... התוכנית [אפשרות תוכנית] ...

תיאור

מזכרות הוא סקריפט bash שמציג פרופיל שימוש בזיכרון של התוכנית, התוכנית. זה
טוען מראש את libmemusage.so ספרייה לתוך הסביבה של המתקשר (דרך LD_PRELOAD
משתנה הסביבה; לִרְאוֹת ld.so(8)). ה libmemusage.so הספרייה עוקבת אחר הקצאת זיכרון
על ידי יירוט שיחות ל malloc(3), calloc(3), חופשי(3), ו ריאלוק(3); אופציונלי, שיחות
ל mmap(2), mremap(2), ו munmap(2) ניתן גם ליירט.

מזכרות יכול להוציא את הנתונים שנאספו בצורה טקסטואלית, או שהוא יכול להשתמש memusagestat(1) (ראה
מה היא -p אפשרות, למטה) כדי ליצור קובץ PNG המכיל ייצוג גרפי של
נתונים שנאספו.

זכרון שימוש תקציר
שורת "סיכום שימוש בזיכרון" פלט על ידי מזכרות מכיל שלושה שדות:

גל סה"כ
סכום של גודל טיעונים מכולם malloc(3) שיחות, תוצרי טיעונים
(nmemb*גודל) מכל calloc(3) שיחות, וסכום של אורך טיעונים מכולם mmap(2)
שיחות. במקרה של ריאלוק(3) ו mremap(2), אם הגודל החדש של an
ההקצאה גדולה מהגודל הקודם, הסכום של כל ההפרשים הללו
(גודל חדש פחות מידה ישן) נוסף.

גל שיא
מקסימום מכולם גודל טיעונים של malloc(3), כל המוצרים של nmemb*גודל of
calloc(3), כולם גודל טיעונים של ריאלוק(3), אורך טיעונים של mmap(2), ו
new_size טיעונים של mremap(2).

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

מייד לאחר שורת הסיכום הזו, טבלה מציגה את מספר השיחות, סך הזיכרון
הוקצו או בוטלו, ומספר השיחות שנכשלו עבור כל פונקציה מיירטת. ל
ריאלוק(3) ו mremap(2), השדה הנוסף "nomove" מציג הקצאות מחדש שהשתנו
הכתובת של בלוק, והשדה הנוסף "דק" מציג הקצאות מחדש שירדו
גודל הבלוק. ל ריאלוק(3), השדה הנוסף "חינם" מציג הקצאות מחדש
שגרם לשחרור בלוק (כלומר, הגודל שהוקצה מחדש היה 0).

ה-"reloc/total memory" של הטבלה פלט על ידי מזכרות אינו משקף מקרים שבהם
ריאלוק(3) משמש להקצאה מחדש של בלוק זיכרון לגודל קטן יותר מבעבר.
זה יכול לגרום לסכום של כל תאי "הזיכרון הכולל" (למעט "חופשי") להיות גדול יותר מה-
תא "זיכרון פנוי/כולל".

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

אפשרויות

-n שם, --progname=שם
שם קובץ התוכנית לפרופיל.

-p פילה, --png=פילה
צור גרפיקת PNG ואחסן אותה פילה.

-d פילה, --נתונים=פילה
צור קובץ נתונים בינאריים ואחסן אותו בו פילה.

-u, --לא מאומצת
אין לחצץ פלט.

-b גודל, --buffer=גודל
לגבות גודל ערכים לפני כתיבתם.

--ללא טיימר
השבת מבוסס טיימר (SIGPROF) דגימה של ערך מצביע מחסנית.

-m, --mmap
גם עקבות mmap(2), mremap(2), ו munmap(2).

-?, - עזרה
הדפס עזרה וצא.

--נוֹהָג
הדפס הודעת שימוש קצרה וצא.

-V, --גִרְסָה
מידע על גרסת הדפסה ויציאה.

האפשרויות הבאות חלות רק בעת יצירת פלט גרפי:

-t, --מבוסס על זמן
השתמש בזמן (ולא במספר קריאות לפונקציה) כקנה המידה של ציר ה-X.

-T, --סה"כ
צייר גם גרף של השימוש הכולל בזיכרון.

--title=שם
השתמש שם ככותרת הגרף.

-x גודל, --x-size=גודל
עשה את הגרף גודל רוחב פיקסלים.

-y גודל, --y-size=גודל
עשה את הגרף גודל פיקסלים גבוהים.

יְצִיאָה סטָטוּס

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

דוגמא

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

$ מזכרות --data=memusage.dat ./a. בחוץ
...
סיכום שימוש בזיכרון: ערימה כוללת: 45200, שיא ערימה: 6440, שיא ערימה: 224
סך השיחות סך הזיכרון שיחות שנכשלו
malloc| 1 400
realloc| 40 44800 0 (nomove:40, דצמבר:19, חינם:0)
calloc| 0 0 0
חינם| 1 440
היסטוגרמה עבור גדלי בלוקים:
192-207 1 2% ================
...
2192-2207 1 2% ================
2240-2255 2 4% ================================
2832-2847 2 4% ================================
3440-3455 2 4% ================================
4032-4047 2 4% ================================
4640-4655 2 4% ================================
5232-5247 2 4% ================================
5840-5855 2 4% ================================
6432-6447 1 2% ================
$ memusagestat memusage.dat memusage.png

תָכְנִית מָקוֹר
#לִכלוֹל
#לִכלוֹל

#define מחזורים 20

int
main (int argc, char *argv [])
{
int i, j;
int * p;

printf("malloc: %zd\n", sizeof(int) * 100);
p = malloc(sizeof(int) * 100);

עבור (i = 0; i < מחזורים; i++) {
אם (אני < מחזורים / 2)
j = i;
אחר
j--;

printf("realloc: %zd\n", sizeof(int) * (j * 50 + 110));
p = realloc(p, sizeof(int) * (j * 50 + 100));

printf("realloc: %zd\n", sizeof(int) * ((j+1) * 150 + 110));
p = realloc(p, sizeof(int) * ((j + 1) * 150 + 110));
}

חופשי (p);
exit(EXIT_SUCCESS);
}

השתמש במזכרות מקוונות באמצעות שירותי onworks.net