स्टैक ओवरफ़्लो तक शेष स्टैक का आकार

Question

लिनक्स पर, सी का उपयोग करके, मान लीजिए कि मेरे पास एक गतिशील रूप से निर्धारित n है जो मुझे एक सरणी (int my_array[n]) में स्टोर करने के लिए तत्वों की संख्या का नामकरण करता है, केवल थोड़े समय के लिए, कहें, एक फ़ंक्शन कॉल, जिससे कॉल किया गया फ़ंक्शन केवल छोटी मेमोरी (कुछ सौ बाइट्स) का उपयोग करता है।

अधिकतर n थोड़ा, कुछ दसवां है। लेकिन कभी-कभी n बड़ा हो सकता है, जितना 1000 या 1'000'000।

मैं कैसे गणना करूं, चाहे मेरा ढेर n*o + p बाइट्स बहने के बिना हो सकता है?

असल में: मेरे ढेर पर कितने बाइट्स छोड़े गए हैं?

Answer 1

दरअसल, checking available stack प्रश्न अच्छा जवाब देता है।

लेकिन एक और व्यावहारिक उत्तर है: कॉल स्टैक पर बड़ा डेटा आवंटित न करें।

आपके मामले में, आप अलग मामले को संभाल सकता है जब n<100 (और फिर alloca के माध्यम से ढेर पर आवंटन, शायद, समझ में आता है) और मामला है जब n>=100 (तब, ढेर पर malloc (या calloc साथ आवंटित) और free इसे मत भूलना)। थ्रेसहोल्ड 100#define -d निरंतर बनाओ।

call stack पर एक सामान्य कॉल फ्रेम वर्तमान लैपटॉप या डेस्कटॉप पर, कुछ किलोबाइट्स पर होना चाहिए (और यदि आपके पास रिकर्सन या धागे हैं तो अधिमानतः कम)। कुल स्टैक स्पेस आमतौर पर कुछ मेगाबाइट्स पर होता है (और कभी-कभी बहुत कम: कर्नेल के अंदर, ढेर आमतौर पर 4 किलोबाइट होते हैं!)।

Answer 2

आप धागे का उपयोग कर रहे है, या आप जानते हैं कि आपके कोड मुख्य ढेर पर निष्पादित हैं, तो

1. रिकार्ड वर्तमान ढेर सूचक जब मुख्य
2. में प्रवेश अपनी दिनचर्या में, वर्तमान ढेर सीमा मिल (देख man getrlimit)
3. वर्तमान ढेर सूचक और कदम 2.

से सीमा के साथ चरण 1 में दर्ज की गई है आप threa उपयोग कर रहे हैं एक के बीच तुलना करें अंतर डीएस और मुख्य के अलावा किसी धागे पर निष्पादित किया जा सकता है, man pthread_getattr_np