2010-10-12 9 views
9

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

मान लीजिए कि मैं 3 जी आवंटित करने के लिए foo = malloc (3 * 1024 * 1024 * 1024) करता हूं, लेकिन 1 जी कंप्यूटर पर स्वैप फ़ाइल के 1 जी के साथ। यह असफल हो जाएगा, है ना?

मुझे क्या करना चाहते हैं कहते हैं कि "मुझे दो एक स्मृति पता श्रेणी foo ... foo + 3 जी जिसमें मैं आवंटन किया जाएगा" इसलिए मैं इस क्षेत्र के भीतर सभी आवंटन सन्निहित हैं गारंटी ले सकते हैं है, लेकिन वास्तव में आवंटन के बिना तुरंत।

उपर्युक्त उदाहरण में, मैं एक बार = malloc (123) कॉल के साथ foo = reserve_memory (3 जी) कॉल का पालन करना चाहता हूं, जिसे आरक्षित किया जाना चाहिए क्योंकि reg_memory ने अभी तक कोई संसाधन नहीं खाया है, यह गारंटी देता है कि बार नहीं होगा श्रेणी foo में हो ... foo + 3 जी।

बाद में मैं foo की सीमा के बाइट 0..234 का उपभोग करने के लिए allocate_for_real (foo, 0,234) की तरह कुछ करता। इस बिंदु पर, कर्नेल कुछ वर्चुअल पेज आवंटित करेगा और उन्हें foo पर मैप करेगा ... foo + 123 + N

क्या यह उपयोगकर्ता स्पेस में संभव है?

(इस का मुद्दा यह है कि में foo ... जरूरत वस्तुओं आस पास होने की और उसके बाद वे बनाई गई हैं यथोचित ले जाया जा सकता है।)

धन्यवाद।

+0

मुझे आशा है कि आप 64-बिट प्लेटफ़ॉर्म पर हैं, या 3 जी ब्लॉक आवंटन सफल होने की संभावना नहीं होगी। – MarkR

+0

वर्चुअल या शारीरिक रूप से संगत? – shodanex

उत्तर

15

संक्षिप्त उत्तर: यह पहले से ही इस तरह से काम करता है।

थोड़ा लंबा जवाब: बुरी खबर यह है कि एक सीमा को आरक्षित करने का कोई विशेष तरीका नहीं है, लेकिन इसे आवंटित नहीं किया जा रहा है। हालांकि, अच्छा समाचार यह है कि जब आप एक सीमा आवंटित करते हैं, तो लिनक्स वास्तव में इसे आवंटित नहीं करता है, यह बाद में आपके द्वारा उपयोग के लिए इसे सुरक्षित रखता है।

लिनक्स का डिफ़ॉल्ट व्यवहार हमेशा एक नया आवंटन स्वीकार करना है, जब तक पता रेंज छोड़ दिया गया हो। जब आप वास्तव में स्मृति का उपयोग करना शुरू करते हैं, तो वहां कुछ मेमोरी बेहतर होती है या कम से कम इसका बैक अप लेना बेहतर होता है। यदि नहीं, तो कर्नेल मुक्त स्मृति के लिए एक प्रक्रिया को मार देगा, आमतौर पर वह प्रक्रिया जो सबसे अधिक स्मृति आवंटित करती है।

तो डिफ़ॉल्ट सेटिंग्स के साथ लिनक्स में समस्या को "मैं कितना आवंटित कर सकता हूं" में स्थानांतरित हो जाता है, "मैं कितना आवंटित कर सकता हूं और फिर भी जब मैं स्मृति का उपयोग शुरू करता हूं तो जीवित रह सकता हूं?"

Here is some info विषय पर।

+0

यह जानना अच्छा है।क्या आप कृपया मुझे बता सकते हैं कि इस पर दस्तावेज़ीकरण कैसे प्राप्त करें? – spraff

+1

@spraff: कुछ ---> http://www.ioremap.net/node/125 –

0

मुझे लगता है कि, एक आसान तरीका यह है कि static सरणी के साथ ऐसा करना आसान होगा।

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

और भौतिक स्मृति की सीमा तक पहुंचने के बाद आपका प्रोग्राम गंभीर रूप से धीमा हो जाएगा और फिर यदि आप स्वैप से बाहर निकलते हैं तो यादृच्छिक रूप से क्रैश हो जाएंगे।

+0

एक बड़ी स्थिर सरणी एक मॉलोक के रूप में काम करेगी, यह अंत में समान है। –

संबंधित मुद्दे

 संबंधित मुद्दे