memusage - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

memusage - ഒരു പ്രോഗ്രാമിന്റെ പ്രൊഫൈൽ മെമ്മറി ഉപയോഗം

സിനോപ്സിസ്

മെമ്മ്യൂസേജ് [ഓപ്ഷൻ]... പ്രോഗ്രാം [പ്രോഗ്രാം ഓപ്ഷൻ]...

വിവരണം

മെമ്മ്യൂസേജ് പ്രോഗ്രാമിന്റെ മെമ്മറി ഉപയോഗം പ്രൊഫൈൽ ചെയ്യുന്ന ഒരു ബാഷ് സ്ക്രിപ്റ്റ് ആണ്, പ്രോഗ്രാം. അത്
പ്രീലോഡ് ചെയ്യുന്നു libmemusage.so വിളിക്കുന്നയാളുടെ പരിതസ്ഥിതിയിലേക്കുള്ള ലൈബ്രറി (വഴി LD_PRELOAD
പരിസ്ഥിതി വേരിയബിൾ; കാണുക ld.so.(8)). ദി libmemusage.so ലൈബ്രറി ട്രെയ്സ് മെമ്മറി അലോക്കേഷൻ
എന്നതിലേക്കുള്ള കോളുകൾ തടസ്സപ്പെടുത്തുന്നതിലൂടെ malloc(3), കാലോക്ക്(3), സ്വതന്ത്ര(3), ഒപ്പം realloc(3); ഓപ്ഷണലായി, കോളുകൾ
ലേക്ക് mmap(2), mremap(2), ഒപ്പം മുൻമാപ്പ്(2) തടസ്സപ്പെടുത്താനും കഴിയും.

മെമ്മ്യൂസേജ് ശേഖരിച്ച ഡാറ്റ വാചക രൂപത്തിൽ ഔട്ട്പുട്ട് ചെയ്യാൻ കഴിയും, അല്ലെങ്കിൽ അത് ഉപയോഗിക്കാം memusagestat(1) (കാണുക
The -p ഓപ്ഷൻ, താഴെ) എന്നതിന്റെ ഗ്രാഫിക്കൽ പ്രാതിനിധ്യം അടങ്ങിയ ഒരു PNG ഫയൽ സൃഷ്ടിക്കാൻ
ശേഖരിച്ച ഡാറ്റ.

മെമ്മറി ഉപയോഗം സംഗ്രഹം
"മെമ്മറി ഉപയോഗ സംഗ്രഹം" ലൈൻ ഔട്ട്പുട്ട് ചെയ്തത് മെമ്മ്യൂസേജ് മൂന്ന് ഫീൽഡുകൾ അടങ്ങിയിരിക്കുന്നു:

കൂമ്പാരം മൊത്തം
തുക വലുപ്പം എല്ലാവരുടെയും വാദങ്ങൾ malloc(3) കോളുകൾ, വാദങ്ങളുടെ ഉൽപ്പന്നങ്ങൾ
(nmemb*വലുപ്പം) എല്ലാം കാലോക്ക്(3) കോളുകൾ, തുക നീളം എല്ലാവരുടെയും വാദങ്ങൾ mmap(2)
വിളിക്കുന്നു. ഈ സന്ദർഭത്തിൽ realloc(3) ഉം mremap(2), ഒരു പുതിയ വലുപ്പമാണെങ്കിൽ
വിഹിതം മുമ്പത്തെ വലുപ്പത്തേക്കാൾ വലുതാണ്, അത്തരം എല്ലാ വ്യത്യാസങ്ങളുടെയും ആകെത്തുക
(പുതിയ വലുപ്പം മൈനസ് പഴയ വലുപ്പം) ചേർത്തു.

കൂമ്പാരം പീക്ക്
എല്ലാം പരമാവധി വലുപ്പം എന്ന വാദങ്ങൾ malloc(3), എല്ലാ ഉൽപ്പന്നങ്ങളും nmemb*വലുപ്പം of
കാലോക്ക്(3), എല്ലാം വലുപ്പം എന്ന വാദങ്ങൾ realloc(3), നീളം എന്ന വാദങ്ങൾ mmap(2), ഒപ്പം
new_size എന്ന വാദങ്ങൾ mremap(2).

സ്റ്റാക്ക് പീക്ക്
നിരീക്ഷിക്കപ്പെടുന്ന ഏതെങ്കിലും ഫംഗ്‌ഷനിലേക്കുള്ള ആദ്യ കോളിന് മുമ്പ്, സ്റ്റാക്ക് പോയിന്റർ വിലാസം
(ബേസ് സ്റ്റാക്ക് പോയിന്റർ) സംരക്ഷിച്ചു. ഓരോ ഫംഗ്ഷൻ കോളിനും ശേഷം, യഥാർത്ഥ സ്റ്റാക്ക്
പോയിന്റർ വിലാസം വായിച്ചു, അടിസ്ഥാന സ്റ്റാക്ക് പോയിന്ററിൽ നിന്നുള്ള വ്യത്യാസം
കണക്കു കൂട്ടി. ഈ വ്യത്യാസങ്ങളുടെ പരമാവധി പിന്നീട് സ്റ്റാക്ക് പീക്ക് ആണ്.

ഈ സംഗ്രഹ രേഖയ്ക്ക് തൊട്ടുപിന്നാലെ, ഒരു പട്ടിക കോളുകളുടെ നമ്പർ, മൊത്തം മെമ്മറി എന്നിവ കാണിക്കുന്നു
അനുവദിച്ചതോ ഡീലോക്കേറ്റ് ചെയ്തതോ, തടസ്സപ്പെട്ട ഓരോ ഫംഗ്ഷനും പരാജയപ്പെട്ട കോളുകളുടെ എണ്ണം. വേണ്ടി
realloc(3) ഉം mremap(2), "nomove" എന്ന അധിക ഫീൽഡ് മാറിയ റീലോക്കേഷനുകൾ കാണിക്കുന്നു
ഒരു ബ്ലോക്കിന്റെ വിലാസം, കൂടാതെ "dec" എന്ന അധിക ഫീൽഡ്, കുറഞ്ഞുപോയ റീലോക്കേഷനുകൾ കാണിക്കുന്നു
ബ്ലോക്കിന്റെ വലിപ്പം. വേണ്ടി realloc(3), അധിക ഫീൽഡ് "ഫ്രീ" റീലോക്കേഷനുകൾ കാണിക്കുന്നു
അത് ഒരു ബ്ലോക്ക് സ്വതന്ത്രമാക്കാൻ കാരണമായി (അതായത്, വീണ്ടും അനുവദിച്ച വലുപ്പം 0 ആയിരുന്നു).

പട്ടികയുടെ "realloc/total memory" ഔട്ട്‌പുട്ട് പ്രകാരം മെമ്മ്യൂസേജ് കേസുകൾ പ്രതിഫലിപ്പിക്കുന്നില്ല
realloc(3) മുമ്പത്തേതിനേക്കാൾ ചെറിയ വലിപ്പമുള്ള മെമ്മറിയുടെ ഒരു ബ്ലോക്ക് വീണ്ടും ലൊക്കേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു.
ഇത് എല്ലാ "മൊത്തം മെമ്മറി" സെല്ലുകളുടെയും ("സ്വതന്ത്ര" ഒഴികെയുള്ള) തുകയെക്കാൾ വലുതാകാൻ ഇടയാക്കും.
"സൌജന്യ/മൊത്തം മെമ്മറി" സെൽ.

ഹിസ്റ്റോഗ്രാം വേണ്ടി ബ്ലോക്ക് വലിപ്പത്തിലും
"ബ്ലോക്ക് വലുപ്പങ്ങൾക്കുള്ള ഹിസ്റ്റോഗ്രാം" മെമ്മറി അലോക്കേഷനുകളുടെ ഒരു തകർച്ച നൽകുന്നു
ബക്കറ്റ് വലുപ്പങ്ങൾ.

ഓപ്ഷനുകൾ

-n പേര്, --പ്രോഗ്നെയിം=പേര്
പ്രൊഫൈലിലേക്കുള്ള പ്രോഗ്രാം ഫയലിന്റെ പേര്.

-p ഫയല്, --png=ഫയല്
PNG ഗ്രാഫിക് സൃഷ്ടിച്ച് അതിൽ സംഭരിക്കുക ഫയല്.

-d ഫയല്, --ഡാറ്റ=ഫയല്
ബൈനറി ഡാറ്റ ഫയൽ സൃഷ്ടിച്ച് അതിൽ സംഭരിക്കുക ഫയല്.

-u, --ബഫർ ചെയ്യാത്തത്
ഔട്ട്പുട്ട് ബഫർ ചെയ്യരുത്.

-b വലുപ്പം, --ബഫർ=വലുപ്പം
ശേഖരിക്കുക വലുപ്പം എൻട്രികൾ എഴുതുന്നതിന് മുമ്പ്.

--നോ-ടൈമർ
ടൈമർ അടിസ്ഥാനമാക്കി പ്രവർത്തനരഹിതമാക്കുക (എസ്ഐജിപിആർഒഎഫ്) സ്റ്റാക്ക് പോയിന്റർ മൂല്യത്തിന്റെ സാമ്പിൾ.

-m, --mmap
കൂടാതെ കണ്ടെത്തുക mmap(2), mremap(2), ഒപ്പം മുൻമാപ്പ്(2).

-?, --സഹായിക്കൂ
സഹായം പ്രിന്റ് ചെയ്‌ത് പുറത്തുകടക്കുക.

--ഉപയോഗം
ഒരു ചെറിയ ഉപയോഗ സന്ദേശം അച്ചടിച്ച് പുറത്തുകടക്കുക.

-V, --പതിപ്പ്
പതിപ്പ് വിവരങ്ങൾ അച്ചടിച്ച് പുറത്തുകടക്കുക.

ഗ്രാഫിക്കൽ ഔട്ട്പുട്ട് സൃഷ്ടിക്കുമ്പോൾ മാത്രമേ ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ ബാധകമാകൂ:

-t, --സമയം അടിസ്ഥാനമാക്കിയുള്ളത്
X അക്ഷത്തിന്റെ സ്കെയിലായി സമയം (ഫംഗ്ഷൻ കോളുകളുടെ എണ്ണത്തിന് പകരം) ഉപയോഗിക്കുക.

-T, --ആകെ
മൊത്തം മെമ്മറി ഉപയോഗത്തിന്റെ ഒരു ഗ്രാഫ് വരയ്ക്കുക.

--ശീർഷകം=പേര്
ഉപയോഗം പേര് ഗ്രാഫിന്റെ തലക്കെട്ടായി.

-x വലുപ്പം, --x-size=വലുപ്പം
ഗ്രാഫ് ഉണ്ടാക്കുക വലുപ്പം പിക്സൽ വീതി.

-y വലുപ്പം, --y-size=വലുപ്പം
ഗ്രാഫ് ഉണ്ടാക്കുക വലുപ്പം ഉയർന്ന പിക്സലുകൾ.

പുറത്ത് പദവി

എക്സിറ്റ് സ്റ്റാറ്റസ് പ്രൊഫൈൽ ചെയ്ത പ്രോഗ്രാമിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസിന് തുല്യമാണ്.

ഉദാഹരണം

ഒരു കൊടുമുടിയിലേക്ക് ഉയരുന്ന സൈക്കിളുകളിൽ മെമ്മറിയുടെ ഒരു ബ്ലോക്ക് വീണ്ടും അനുവദിക്കുന്ന ഒരു ലളിതമായ പ്രോഗ്രാം ചുവടെയുണ്ട്
അതിനുമുമ്പ്, പൂജ്യത്തിലേക്ക് മടങ്ങുന്ന ചെറിയ ബ്ലോക്കുകളിൽ മെമ്മറി ചാക്രികമായി പുനഃസ്ഥാപിക്കുന്നു.
പ്രോഗ്രാം കംപൈൽ ചെയ്ത് ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിച്ചതിന് ശേഷം, മെമ്മറിയുടെ ഒരു ഗ്രാഫ്
പ്രോഗ്രാമിന്റെ ഉപയോഗം ഫയലിൽ കാണാം memusage.png:

$ മെമ്മ്യൂസേജ് --data=memusage.dat ./a.out
...
മെമ്മറി ഉപയോഗത്തിന്റെ സംഗ്രഹം: ആകെ കൂമ്പാരം: 45200, ഹീപ്പ് പീക്ക്: 6440, സ്റ്റാക്ക് പീക്ക്: 224
മൊത്തം കോളുകൾ മൊത്തം മെമ്മറി പരാജയപ്പെട്ട കോളുകൾ
malloc| 1 400 0
realloc| 40 44800 0 (nomove:40, dec:19, free: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

പ്രോഗ്രാം ഉറവിടം
#ഉൾപ്പെടുന്നു
#ഉൾപ്പെടുന്നു

#സൈക്കിളുകൾ 20 നിർവ്വചിക്കുക

int
പ്രധാന(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++) {
എങ്കിൽ (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_SUCCESS);
}

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് മെമുസേജ് ഓൺലൈനായി ഉപയോഗിക്കുക