मेम्यूजेज - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

मेम्यूजेज - किसी प्रोग्राम का प्रोफ़ाइल मेमोरी उपयोग

SYNOPSIS

memusage [विकल्प] ... कार्यक्रम [प्रोग्रामविकल्प] ...

वर्णन

memusage एक बैश स्क्रिप्ट है जो प्रोग्राम के मेमोरी उपयोग को प्रोफाइल करती है, कार्यक्रम. यह
प्रीलोड करता है libmemusage.so कॉल करने वाले के वातावरण में लाइब्रेरी (के माध्यम से) LD_PRELOAD
वातावरण विविधता; देख ld.so(8))। NS libmemusage.so लाइब्रेरी मेमोरी आवंटन का पता लगाती है
कॉल को इंटरसेप्ट करके malloc(3) कॉलोक(3) मुक्त(3) और, रीयलोक(3); वैकल्पिक रूप से, कॉल
सेवा मेरे mmap(2) mremap(2) और, मुनमैप(2) अवरोधन भी किया जा सकता है।

memusage एकत्रित डेटा को पाठ्य रूप में आउटपुट कर सकता है, या इसका उपयोग कर सकता है memusagestat(1) (देखें
la -p विकल्प, नीचे) एक पीएनजी फ़ाइल बनाने के लिए जिसमें ग्राफिकल प्रतिनिधित्व शामिल है
डेटा एकत्रित किया.

याद प्रयोग सारांश
द्वारा "मेमोरी उपयोग सारांश" लाइन आउटपुट memusage इसमें तीन फ़ील्ड शामिल हैं:

ढेर कुल
का योग आकार सभी के तर्क malloc(3) कॉल, तर्क के उत्पाद
(nmemb*आकार) के सभी कॉलोक(3) कॉल, और का योग लंबाई सभी के तर्क mmap(2)
कॉल. के मामले में रीयलोक(3) और mremap(2), यदि एक का नया आकार
आवंटन पिछले आकार से बड़ा है, ऐसे सभी अंतरों का योग
(नया आकार घटाकर पुराना आकार) जोड़ा जाता है।

ढेर शिखर
सबसे ज्यादा आकार के तर्क malloc(3), के सभी उत्पाद nmemb*आकार of
कॉलोक(3), सभी आकार के तर्क रीयलोक(3) लंबाई के तर्क mmap(2) और,
नया_आकार के तर्क mremap(2).

धुआँरा शिखर
किसी भी मॉनिटर किए गए फ़ंक्शन पर पहली कॉल से पहले, स्टैक पॉइंटर पता
(बेस स्टैक पॉइंटर) सहेजा गया है। प्रत्येक फ़ंक्शन कॉल के बाद, वास्तविक स्टैक
सूचक पता पढ़ा जाता है और बेस स्टैक सूचक से अंतर होता है
गणना की गई। इनमें से अधिकतम अंतर तब स्टैक शिखर होता है।

इस सारांश पंक्ति के तुरंत बाद, एक तालिका संख्या कॉल, कुल मेमोरी दिखाती है
आवंटित या निरस्त किया गया, और प्रत्येक इंटरसेप्ट किए गए फ़ंक्शन के लिए विफल कॉल की संख्या। के लिए
रीयलोक(3) और mremap(2), अतिरिक्त फ़ील्ड "नोमूव" उन पुनर्आवंटनों को दिखाता है जो बदल गए हैं
एक ब्लॉक का पता, और अतिरिक्त "dec" फ़ील्ड कम हुए पुन:आबंटन को दर्शाता है
ब्लॉक का आकार. के लिए रीयलोक(3), अतिरिक्त फ़ील्ड "मुक्त" पुनः आवंटन दिखाता है
जिसके कारण एक ब्लॉक मुक्त हो गया (यानी, पुनः आवंटित आकार 0 था)।

तालिका आउटपुट की "रियललोक/कुल मेमोरी"। memusage जहां मामलों को प्रतिबिंबित नहीं करता
रीयलोक(3) का उपयोग मेमोरी के एक ब्लॉक को पहले की तुलना में छोटे आकार में पुनः आवंटित करने के लिए किया जाता है।
इससे सभी "कुल मेमोरी" कोशिकाओं ("मुक्त" को छोड़कर) का योग इससे बड़ा हो सकता है
"मुक्त/कुल मेमोरी" सेल।

हिस्टोग्राम एसटी खंड आकार
"ब्लॉक आकार के लिए हिस्टोग्राम" मेमोरी आवंटन को विभिन्न भागों में विभाजित करता है
बाल्टी का आकार।

विकल्प

-n नाम, --progname=नाम
प्रोफ़ाइल में प्रोग्राम फ़ाइल का नाम.

-p पट्टिका, --पीएनजी =पट्टिका
पीएनजी ग्राफिक बनाएं और इसे स्टोर करें पट्टिका.

-d पट्टिका, --डेटा=पट्टिका
बाइनरी डेटा फ़ाइल जेनरेट करें और इसे स्टोर करें पट्टिका.

-u, --अनबफर्ड
आउटपुट को बफ़र न करें.

-b आकार, --बफ़र=आकार
लीजिए आकार प्रविष्टियाँ लिखने से पहले।

--नो-टाइमर
टाइमर-आधारित अक्षम करें (सिगप्रोफ) स्टैक पॉइंटर मान का नमूनाकरण।

-m, --एमएमएपी
साथ ही ट्रेस करें mmap(2) mremap(2) और, मुनमैप(2).

-?, --मदद
मदद प्रिंट करें और बाहर निकलें।

--उपयोग
एक संक्षिप्त उपयोग संदेश प्रिंट करें और बाहर निकलें।

-V, --संस्करण
संस्करण की जानकारी प्रिंट करें और बाहर निकलें।

निम्नलिखित विकल्प केवल ग्राफ़िकल आउटपुट उत्पन्न करते समय लागू होते हैं:

-t, --समय पर आधारित
एक्स अक्ष के पैमाने के रूप में समय (फ़ंक्शन कॉल की संख्या के बजाय) का उपयोग करें।

-T, --कुल
कुल मेमोरी उपयोग का एक ग्राफ भी बनाएं।

--शीर्षक=नाम
उपयोग नाम ग्राफ़ के शीर्षक के रूप में.

-x आकार, --x-आकार=आकार
ग्राफ बनाओ आकार पिक्सेल चौड़ा।

-y आकार, --y-आकार=आकार
ग्राफ बनाओ आकार पिक्सेल उच्च।

बाहर निकलें स्थिति

निकास स्थिति प्रोफाइल प्रोग्राम की निकास स्थिति के बराबर है।

उदाहरण

नीचे एक सरल प्रोग्राम है जो चरम पर पहुंचने वाले चक्रों में मेमोरी के एक ब्लॉक को पुनः आवंटित करता है
इससे पहले चक्रीय रूप से मेमोरी को छोटे ब्लॉकों में पुनः आवंटित करना जो शून्य पर वापस आ जाते हैं।
प्रोग्राम को संकलित करने और निम्नलिखित कमांड चलाने के बाद, मेमोरी का एक ग्राफ
प्रोग्राम का उपयोग फ़ाइल में पाया जा सकता है memusage.png:

$ memusage --डेटा=memusage.dat ./ए.बाहर
...
मेमोरी उपयोग सारांश: ढेर कुल: 45200, ढेर शिखर: 6440, ढेर शिखर: 224
कुल कॉल, कुल मेमोरी, विफल कॉल
मॉलोक| 1 400 0
रीयलोक| 40 44800 0 (नाम:40, दिसंबर:19, मुफ़्त:0)
कॉलोक| 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 * p;

प्रिंटफ ("मॉलोक: %zd\n", साइजऑफ(int) * 100);
पी = मॉलोक(आकार(int) * 100);

(i = 0; i < CYCLES; i++) के लिए {
यदि (i <चक्र/2)
जे = मैं;
अन्य
जे--;

प्रिंटफ ("realloc: %zd\n", sizeof(int) * (j * 50 + 110));
पी = रियललोक(पी, साइजऑफ(इंट) * (जे * 50 + 100));

प्रिंटफ ("realloc: %zd\n", sizeof(int) * ((j+1) * 150 + 110));
पी = रियललोक(पी, साइजऑफ(इंट) * ((जे + 1) * 150 + 110));
}

मुक्त (पी);
बाहर निकलें(EXIT_SUCCESS);
}

onworks.net सेवाओं का उपयोग करके ऑनलाइन मेम्यूजेज का उपयोग करें