🌤️ 🚴🏼 🔼 स्टैक चर - तेज और कभी-कभी मृत 🎛️ 🕴🏻 👆🏾

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

सीमा इस प्रकार है - आपको स्टैक पर बहुत अधिक मेमोरी आवंटित करने का प्रयास नहीं करना चाहिए। बहुत ज्यादा? यह कितना है? उत्तर उतना स्पष्ट नहीं है जितना आप पहली नज़र में सोच सकते हैं।

बहुत अधिक - बस से अधिक उपलब्ध है। बयान त्रुटिहीन रूप से सटीक है, लेकिन बहुत उपयोगी नहीं है।

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

कितना स्टैक उपयोग किया जाता है यह भी हमेशा डेवलपर तक नहीं होता है।

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

दूसरे, उपयोगकर्ता कोड में भी यह स्पष्ट नहीं है कि स्टैक मेमोरी का कितना उपयोग किया जाता है। पाठक नाराज हो जाएगा - क्या यह स्पष्ट नहीं है? सभी स्थानीय चर के लिए मेमोरी की मात्रा लेना और गणना करना काफी सरल है। उदाहरण के लिए, यहाँ ...

 //sample 0 void trivial() { char buffer[4 * 1000 * 1000] = {}; MessageBoxA( 0, buffer, buffer, 0 ); }

... जाहिर है, 4 मेगाबाइट मेमोरी का उपयोग किया जाता है, और विंडोज पर (डिफ़ॉल्ट स्टैक आकार के साथ) यह निश्चित रूप से उड़ान नहीं भरेगा।

खैर, फिर उदाहरण अधिक जटिल है। हम ideone.com पर जाते हैं। अस्वीकरण: ideone.com gcc-4.3.4 पर C ++ में पोस्ट लिखने के समय उपयोग किया गया था, gcc के अन्य संस्करणों में व्यवहार भिन्न हो सकता है। हम निम्नलिखित कोड आज़माते हैं:

 //sample 1 #include <stdio.h> int main() { char buffer[7 * 1000 * 1000] = {}; printf( "%s", buffer ); }

परिणाम सफलता है। ठीक है, अब यह प्रयास करें:

 //sample 2 #include <stdio.h> #include <stdlib.h> int main() { if( rand() ) { char buffer[7 * 1000 * 1000] = {}; printf( "%s", buffer ); } else { char buffer[6 * 1000 * 1000] = {}; printf( "%s", buffer ); } }

अत्यधिक अनपेक्षित

परिणाम एक रनटाइम त्रुटि है। क्या हुआ? क्या कॉल रैंड () स्टैक से बाहर चला गया?

यह बहुत ही सरल है - अधिकांश C ++ कार्यान्वयन में, फ़ंक्शन के काम की शुरुआत में, इस फ़ंक्शन के लिए आवश्यक स्टैक मेमोरी की पूरी मात्रा एक ही बार में आवंटित की जाती है - कंपाइलर फ़ंक्शन की शुरुआत में "चयन करें" कोड को सम्मिलित करता है (Visual C ++ में, _chkstk () फ़ंक्शन का उपयोग इसके लिए किया जाता है। यह आवंटित करने के लिए कितना है।) संकलक, जो चर को स्मृति में रखने का निर्णय करता है, उसके आधार पर (कुछ चर रजिस्टर में मैप किए जाते हैं, और कुछ मृत कोड में समाप्त हो सकते हैं और बस हटा दिए जा सकते हैं) और किस क्रम में।

दूसरे उदाहरण में, कंपाइलर ने फैसला किया कि दोनों सरणियों के लिए मेमोरी आवंटित करना आवश्यक है, यह ध्यान रखते हुए कि इन सरणियों को शाखा ऑपरेटर की पारस्परिक रूप से अनन्य शाखाओं में आवंटित किया जाता है। मानक इस व्यवहार की अनुमति देता है (आईएसओ / आईईसी 14882 का खंड 3.7: 2003 (ई) "न्यूनतम जीवन समय") को संदर्भित करता है।

किसी विशेष फ़ंक्शन की स्टैक मेमोरी खपत, अन्य चीजों के बीच, इस बात पर निर्भर करती है कि कंपाइलर उस फ़ंक्शन में चर द्वारा कब्जा की गई मेमोरी का पुन: उपयोग कर सकता है या नहीं। उदाहरण के लिए, gcc-4.3.4 दूसरे उदाहरण में विफल रहा। दृश्य C ++ 10 दूसरे उदाहरण के साथ मुकाबला करता है, लेकिन इस मामले में सामना नहीं करता है (यह माना जाता है कि स्टैक का आकार 1 मेगाबाइट है):

 //sample 3 class Temp { public: Temp() { memset( buffer, 0, sizeof( buffer ) ); printf( "%S", buffer ); } void Process() { printf( "%S", buffer ); } private: WCHAR buffer[300 * 1024]; }; int _tmain(int argc, _TCHAR* argv[]) { switch( rand() ) { case 1: Temp().Process(); break; case 2: Temp().Process(); break; default: break; } }

अब पाठक इस बात पर आपत्ति करेंगे कि "ढेर पर ऐसी बड़ी वस्तुओं के लिए स्मृति आवंटित करने के लिए कुछ भी नहीं है", और यह एक और बिल्कुल सच और बिल्कुल बेकार बयान होगा। वास्तविक दुनिया में, स्टिक थकावट कम मूर्खतापूर्ण कारणों से होती है।

उदाहरण के लिए, 19 शाखाओं के साथ एक स्विच था, जिसमें से प्रत्येक में एक अस्थायी ऑब्जेक्ट बनाया गया था जैसा कि ऊपर दिए गए उदाहरण में है। कोड ने वर्षों तक काम किया। फिर उन्होंने अपनी अस्थायी वस्तु के साथ 20 वीं शाखा को जोड़ा। स्टैक था, कहते हैं, 256 किलोबाइट, फ़ंक्शन कॉल 56 से पहले ही उपयोग किया जा चुका था। स्टैक को पूरी तरह से समाप्त करने के लिए, फिर यह पर्याप्त है कि प्रत्येक अस्थायी ऑब्जेक्ट औसतन 20 किलोबाइट से थोड़ा अधिक है, जो कि विंडोज डेवलपर के लिए इस दृष्टि से इतना धुंधला नहीं है जो मेगाबाइट स्टैक के लिए उपयोग किया जाता है। 20 किलोबाइट - अभी भी "अच्छे डेवलपर्स स्टैक पर आवंटित नहीं करते हैं"? यदि स्टैक लगभग समाप्त हो जाता है तो अच्छा और 2 किलोबाइट ऑब्जेक्ट पर्याप्त होता है।

क्या किया जा सकता है? तीन विकल्प।

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

विकल्प संख्या दो वस्तुओं को कम करना है। शायद 256-किलोबाइट सरणी का उपयोग करना आवश्यक नहीं है, लेकिन क्या आप 4-किलोबाइट एक के साथ कर सकते हैं? यह हमेशा संभव नहीं होता है और यह अतिप्रवाह के जोखिम को बाहर नहीं करता है, लेकिन कई मामलों में इसे काफी कम कर देता है।

विकल्प संख्या तीन फ़ंक्शन को कई में विभाजित करना है, ताकि गैर-अतिव्यापी जीवनकाल वाली वस्तुओं के लिए स्मृति को विभिन्न कार्यों से आवंटित किया जाए।

इस तथ्य के लिए तैयार रहें कि कंपाइलर हमेशा स्टैक चर के लिए मेमोरी आवंटित नहीं करता है क्योंकि डेवलपर को उम्मीद है। डार्विन पुरस्कार जीतना लंबे समय तक इतना आसान नहीं रहा।

दिमित्री मेश्चेरीकोव,

डेवलपर उत्पाद विभाग

स्टैक चर - तेज और कभी-कभी मृत

More articles: