STM32 और अन्य माइक्रोकंट्रोलर पर सरलतम मेमोरी प्रोफाइलिंग

"अनुभव के साथ, सही स्टैक आकार की गणना करने के लिए एक मानक, वैज्ञानिक दृष्टिकोण आता है: एक यादृच्छिक संख्या और सर्वश्रेष्ठ के लिए आशा करें।"
- जैक गन्सल, "आर्ट ऑफ़ डिज़ाइनिंग एंबेडेड सिस्टम"

नमस्कार, हेब्र!

जैसा कि लग सकता है अजीब है, "STM32 प्राइमरों" के विशाल बहुमत में मैंने विशेष रूप से और माइक्रोकंट्रोलर को सामान्य रूप से देखा है, आम तौर पर मेमोरी आवंटन, स्टैक प्लेसमेंट और सबसे महत्वपूर्ण बात, स्मृति अतिप्रवाह को रोकने के रूप में ऐसा कुछ भी नहीं है - जिसके परिणामस्वरूप एक क्षेत्र दूसरे को अस्त-व्यस्त करता है और सब कुछ ढह जाता है, आमतौर पर करामाती प्रभावों के साथ।

यह आंशिक रूप से अपेक्षाकृत चिकना माइक्रोकंट्रोलर के साथ डिबग बोर्डों पर किए गए प्रशिक्षण परियोजनाओं की सादगी के कारण है, जहां एक एलईडी ब्लिंक करके मेमोरी की कमी में उड़ान भरना मुश्किल है - हालांकि, हाल ही में, शुरुआत के शौकीनों के लिए भी, संदर्भ, उदाहरण के लिए, STM32F030F4P6 प्रकार नियंत्रक अधिक से अधिक आम हैं। , आसान स्थापित करने के लिए, एक पैसा लायक है, लेकिन किलोबाइट्स की एक मेमोरी यूनिट के साथ भी।

इस तरह के नियंत्रक आपको अपने लिए काफी गंभीर चीजें करने की अनुमति देते हैं (अच्छी तरह से, यहां, उदाहरण के लिए, एसटीएम 32 एफ 042 के 6 टी 6 के साथ 6 केबी रैम पर हमारे लिए पूरी तरह से उपयुक्त माप किया गया था , जहां से 100 से अधिक बाइट्स मुफ्त रहते हैं, लेकिन स्मृति के साथ काम करते समय, आपको एक निश्चित मात्रा में मेमोरी की आवश्यकता होती है। सटीकता।

मैं इस सटीकता के बारे में बात करना चाहता हूं। लेख छोटा होगा, पेशेवर कुछ नया नहीं सीखेंगे - लेकिन शुरुआती लोगों के लिए यह ज्ञान अत्यधिक अनुशंसित है।

कॉर्टेक्स-एम कोर पर आधारित एक माइक्रोकंट्रोलर पर एक विशिष्ट परियोजना में, रैम में चार वर्गों में एक सशर्त विभाजन होता है:

• डेटा - एक विशिष्ट मूल्य द्वारा आरंभिक डेटा
• bss - शून्य से आरंभिक डेटा
• ढेर - ढेर (डायनामिक क्षेत्र जिसमें मेमोरी को स्पष्ट रूप से मॉलोक का उपयोग करके आवंटित किया गया है)
• स्टैक - स्टैक (डायनेमिक रीजन जिसमें से मेमोरी को संकलक द्वारा आबंटित किया गया है)

नवजात क्षेत्र भी कभी-कभी हो सकता है (अनइंस्टॉल किए गए चर - वे सुविधाजनक हैं कि वे रिबूट के बीच मूल्य को बनाए रखते हैं), यहां तक ​​कि कम बार, विशिष्ट कार्यों के लिए आवंटित कुछ अन्य क्षेत्र।

वे एक विशिष्ट तरीके से भौतिक स्मृति में स्थित हैं - तथ्य यह है कि एआरएम कोर पर माइक्रोकंट्रोलर में स्टैक ऊपर से नीचे तक बढ़ता है। इसलिए, यह रैम के अंत में शेष मेमोरी ब्लॉकों से अलग स्थित है:



डिफ़ॉल्ट रूप से, इसका पता आमतौर पर नवीनतम रैम पते के बराबर होता है, और वहां से यह बढ़ने के साथ-साथ नीचे चला जाता है - और स्टैक की एक बेहद अप्रिय विशेषता इससे बाहर हो जाती है: यह bss तक पहुंच सकता है और इसके शीर्ष को फिर से लिख सकता है, और आप किसी भी स्पष्ट तरीके से इसके बारे में नहीं जानते हैं।

स्थिर और गतिशील स्मृति क्षेत्र

सभी मेमोरी को दो श्रेणियों में विभाजित किया जाता है - स्टेटिकली एलोकेटेड, यानी। मेमोरी, जिसकी कुल मात्रा कार्यक्रम के पाठ से स्पष्ट है और इसके निष्पादन के क्रम पर निर्भर नहीं है, और गतिशील रूप से आवंटित किया गया है, जिनमें से आवश्यक मात्रा कार्यक्रम की प्रगति पर निर्भर करती है।

उत्तरार्द्ध में एक ढेर शामिल है (जिसमें से हम मॉलॉक का उपयोग करके चांस लेते हैं और मुफ्त का उपयोग करके लौटते हैं) और एक स्टैक जो बढ़ता है और खुद से सिकुड़ता है।

आम तौर पर बोलते हुए, माइक्रोकंट्रोलर्स पर मॉलोक का उपयोग करना बहुत हतोत्साहित किया जाता है जब तक कि आपको पता नहीं है कि आप वास्तव में क्या कर रहे हैं। वे जो मुख्य समस्या ला रहे हैं, वह है स्मृति विखंडन - यदि आप 10 बाइट्स के 10 टुकड़े आवंटित करते हैं, और फिर हर सेकंड मुफ्त देते हैं, तो आपको मुफ्त 50 बाइट्स नहीं मिलेंगे। आपको प्रत्येक 10 बाइट्स के 5 मुफ्त टुकड़े मिलेंगे।

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

इस समस्या के आसपास काम करने के तरीके हैं - विशेष मैलोकोक कार्यान्वयन जो एक सांख्यिकीय रूप से आवंटित क्षेत्र के भीतर काम करते हैं, न कि संपूर्ण रैम, प्रोग्राम लॉजिक स्तर पर संभव विखंडन को ध्यान में रखते हुए मॉलोक का सावधानीपूर्वक उपयोग आदि। - लेकिन सामान्य रूप से मॉलॉक में स्पर्श न करना बेहतर है ।

सीमाओं और पतों के साथ सभी मेमोरी क्षेत्रों को .LD एक्सटेंशन के साथ एक फ़ाइल में पंजीकृत किया जाता है, जो लिंकर प्रोजेक्ट बनाते समय उन्मुख होता है।

सांख्यिकीय रूप से आवंटित स्मृति

इसलिए, सांख्यिकीय रूप से आवंटित मेमोरी से, हमारे पास दो क्षेत्र हैं - bss और डेटा, जो केवल औपचारिक रूप से भिन्न होते हैं। जब सिस्टम को इनिशियलाइज़ किया जाता है, तो डेटा ब्लॉक को फ़्लैश से कॉपी किया जाता है, जहाँ इसके लिए आवश्यक इनिशियलाइज़ेशन वैल्यूज़ को स्टोर किया जाता है, bss ब्लॉक को केवल शून्य से भरा जाता है (कम से कम इसे शून्य से भरना एक अच्छा रूप माना जाता है)।

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

हालाँकि, यह अभी हमारी रुचि नहीं है - लेकिन हम कैसे समझेंगे कि क्या हमारा डेटा हमारे नियंत्रक की रैम में भी फिट बैठता है।

यह बहुत ही सरलता से पहचाना जाता है - एक एकल पैरामीटर के साथ आर्म-नो-ईबी-आकार उपयोगिता द्वारा - हमारे कार्यक्रम की संकलित ईएलएफ फ़ाइल (अक्सर इसका कॉल मेकफाइल के अंत में डाला जाता है, क्योंकि यह सुविधाजनक है):



यहां पाठ फ्लैश में पड़े प्रोग्राम डेटा की मात्रा है, और बीएसएस और डेटा रैम में हमारे सांख्यिकीय रूप से आवंटित क्षेत्र हैं। अंतिम दो कॉलम हमें परेशान नहीं करते हैं - यह पहले तीन का योग है, इसका कोई व्यावहारिक अर्थ नहीं है।

कुल में, रैम में सांख्यिकीय रूप से हमें bss + डेटा बाइट्स की आवश्यकता है, इस मामले में - 5324 बाइट्स। नियंत्रक में 6144 बाइट्स रैम है, हम मॉलोक का उपयोग नहीं करते हैं, 820 बाइट्स बने रहते हैं।

जो ढेर पर हमारे लिए पर्याप्त होना चाहिए।

लेकिन पर्याप्त है? क्योंकि यदि नहीं, तो हमारा स्टैक हमारे अपने डेटा तक बढ़ जाएगा, और फिर पहले यह डेटा को अधिलेखित कर देगा, फिर डेटा इसे अधिलेखित कर देगा, और फिर सब कुछ क्रैश हो जाएगा। इसके अलावा, पहले और दूसरे बिंदुओं के बीच, प्रोग्राम यह महसूस किए बिना काम करना जारी रख सकता है कि डेटा में कचरा है जो इसे संसाधित करता है। सबसे खराब स्थिति में, यह वह डेटा होगा जो आपने तब लिखा था जब सब कुछ स्टैक के क्रम में था, और अब आप सिर्फ पढ़ते हैं - उदाहरण के लिए, कुछ सेंसर के अंशांकन पैरामीटर - और फिर आपके पास यह समझने का कोई स्पष्ट तरीका नहीं है कि उनके लिए सब कुछ खराब है। यह कार्यक्रम चलता रहेगा, जैसे कि कुछ भी नहीं हुआ था, आपको आउटपुट पर कचरा दे रहा था।

गतिशील रूप से आवंटित स्मृति

और यहां सबसे दिलचस्प हिस्सा शुरू होता है - यदि आप कहानी को एक वाक्यांश में कम करते हैं, तो स्टैक के आकार को पहले से निर्धारित करना लगभग असंभव है ।

सैद्धांतिक रूप से , आप कंपाइलर को प्रत्येक व्यक्तिगत फ़ंक्शन द्वारा उपयोग किए गए स्टैक का आकार देने के लिए कह सकते हैं, फिर इसे अपने प्रोग्राम के निष्पादन ट्री को वापस करने के लिए कह सकते हैं, और इसमें प्रत्येक शाखा के लिए इस ट्री में मौजूद सभी फ़ंक्शन के ढेर की गणना करते हैं। किसी भी अधिक या कम जटिल कार्यक्रम के लिए यह अकेले आपको काफी समय लगेगा।

तब आपको याद आता है कि किसी भी समय एक रुकावट आ सकती है, जिसके प्रोसेसर को भी मेमोरी की आवश्यकता होती है।

फिर - कि दो या तीन नेस्टेड व्यवधान हो सकते हैं, जिनमें से हैंडलर ...

सामान्य तौर पर, आप समझते हैं। एक विशिष्ट कार्यक्रम के लिए स्टैक को गिनने की कोशिश एक रोमांचक और आम तौर पर उपयोगी गतिविधि है, लेकिन अक्सर आप ऐसा नहीं करेंगे।

इसलिए, व्यवहार में, एक तकनीक का उपयोग किया जाता है जो आपको कम से कम किसी तरह से यह समझने की अनुमति देता है कि क्या हमारे जीवन में सब कुछ अच्छी तरह से विकसित होता है - तथाकथित "मेमोरी पेंटिंग" (मेमोरी पेंटिंग)।

इस पद्धति में जो सुविधाजनक है वह यह है कि यह आपके द्वारा उपयोग किए जाने वाले डिबगिंग टूल पर निर्भर नहीं करता है, और यदि सिस्टम में जानकारी के आउटपुट के कम से कम कुछ साधन हैं, तो आप डिबगिंग टूल के बिना बिल्कुल भी कर सकते हैं।

इसका सार यह है कि हम बीएसएस के अंत से लेकर कार्यक्रम के निष्पादन के बहुत शुरुआती चरण में कहीं न कहीं स्टैक के अंत तक पूरे सरणी को भरते हैं, जब स्टैक अभी भी बिल्कुल छोटा है, उसी मूल्य के साथ।

इसके अलावा, यह जाँच करते हुए कि यह मान किस पते पर पहले ही गायब हो चुका है, हम समझते हैं कि स्टैक कहां गया। चूँकि एक बार मिटाया हुआ रंग खुद ही बहाल नहीं होगा, इसलिए जाँच को छिटपुट रूप से किया जा सकता है - यह अधिकतम स्टैक के आकार को दिखाएगा।

पेंट के रंग को परिभाषित करें - विशिष्ट मूल्य कोई फर्क नहीं पड़ता, नीचे मैंने बस अपने बाएं हाथ की दो उंगलियों के साथ टैप किया। मुख्य बात 0 और एफएफ का चयन नहीं करना है:

#define STACK_CANARY_WORD (0xCACACACAUL)

- , -, :

volatile unsigned *top, *start;
__asm__ volatile ("mov %[top], sp" : [top] "=r" (top) : : );
start = &_ebss;
while (start < top) {
    *(start++) = STACK_CANARY_WORD;
}

? top , —  ; start —  bss (, , *.ld — libopencm3). bss .

:

unsigned check_stack_size(void) {
    /* top of data section */
    unsigned *addr = &_ebss;

    /* look for the canary word till the end of RAM */
    while ((addr < &_stack) && (*addr == STACK_CANARY_WORD)) {
        addr++;
    }
    
    return ((unsigned)&_stack - (unsigned)addr);
}

_ebss , _stack —  , , , , .

.

— - check_stack_size() , , , .

.

712 — 6 108 .

Word of caution

— , , 100-% . , , , , , . , , -, 10-20 %, 108 .

, , , .

P.S. RTOS — MSP, , PSP. , — .