💇 📿 🌿 पायथन मेमोरी मैनेजमेंट: मेमोरी फ्रैग्मेंटेशन के बारे में थोड़ा ✋🏻 🐄 💙

~~इस लेख पर कुछ विचार।~~

हाल ही में मुझे इस बात में दिलचस्पी हुई कि ~~64-बिट उबंटू के लिए~~ पायथन मेमोरी प्रबंधन, अजगर में पायथन 3 के लिए कैसे काम करता है।

सिद्धांत की बिट

ग्लिबक सिस्टम लाइब्रेरी में एक मॉलोक एलोकेटर है। प्रत्येक प्रक्रिया में एक मेमोरी क्षेत्र होता है जिसे ढेर कहा जाता है। मैल्मोक फ़ंक्शन को कॉल करके गतिशील रूप से मेमोरी आवंटित करने से, हमें इस प्रक्रिया के ढेर से एक हिस्सा मिलता है। यदि अनुरोधित मेमोरी का आकार छोटा है (128KB से अधिक नहीं), तो मेमोरी को मुफ्त विखंडू की सूची से लिया जा सकता है। यदि यह संभव नहीं है, तो मेमोरी को mmap ~~(sbrk, brk)~~ सिस्टम कॉल का उपयोग करके ~~आवंटित किया~~ जाएगा। Mmap सिस्टम कॉल भौतिक मेमोरी में वर्चुअल मेमोरी को मैप करता है। मेमोरी को 4KB पृष्ठों में प्रदर्शित किया जाता है। बड़े चंक्स (128KB से अधिक) हमेशा mmap सिस्टम कॉल के माध्यम से आवंटित किए जाते हैं। स्मृति को मुक्त करते समय, यदि एक मुक्त छोटा हिस्सा अनफ़रोज़ेन मेमोरी के एक क्षेत्र पर सीमाओं का है, तो मेमोरी का हिस्सा ऑपरेटिंग सिस्टम पर वापस आ सकता है। बड़े टुकड़े तुरंत ऑपरेटिंग सिस्टम पर लौटते हैं।

सी में आवंटनकर्ताओं पर एक व्याख्यान से ली गई जानकारी ।

सीपीथॉन के पास "निजी हीप" के लिए अपना स्वयं का आवंटनकर्ता (PyMalloc) है और प्रत्येक प्रकार की वस्तु के लिए आवंटनकर्ता जो पहले "शीर्ष पर" काम करते हैं। PyMalloc ऑपरेटिंग सिस्टम लाइब्रेरी में Arenas नामक मॉलोक के माध्यम से 256KB मेमोरी चंक्स का अनुरोध करता है। वे बदले में, 4KB द्वारा पूल में विभाजित हैं। प्रत्येक पूल को एक निश्चित आकार के विखंडू में विभाजित किया गया है, और प्रत्येक को 64 आकारों में से एक भाग में विभाजित किया जा सकता है।

प्रत्येक प्रकार के लिए आवंटन पहले से ही आवंटित चंक्स का उपयोग करते हैं, यदि कोई हो। यदि कोई नहीं हैं, तो PyMalloc पहले एरिना से एक नया पूल जारी करेगा, जिसमें नए पूल के लिए एक जगह है (Arenas "अधिभोग के अवरोही क्रम में" क्रमबद्ध हैं)। यदि यह काम नहीं करता है, तो PyMalloc OS से एक नए एरिना के लिए पूछता है। सिवाय जब अनुरोधित मेमोरी का आकार 512B से अधिक है, तो सिस्टम लाइब्रेरी से मेमोरी को सीधे मॉलोक के माध्यम से आवंटित किया जाता है।

जब कोई ऑब्जेक्ट हटा दिया जाता है, तो स्मृति ओएस पर वापस नहीं आती है, लेकिन चंक्स बस संबंधित ताल, और पूल से एरेनास पर लौटते हैं। अखाड़ा ऑपरेटिंग सिस्टम में लौटता है जब सभी चंक्स इससे मुक्त हो जाते हैं। इससे यह पता चलता है कि यदि एरिना में अपेक्षाकृत कम संख्या में चंक्स का उपयोग किया जाएगा, तो एरिना में सभी समान मेमोरी का उपयोग पीवीएम द्वारा किया जाएगा। लेकिन चूंकि 128KB से अधिक के चेंज को एमएमएपी के माध्यम से आवंटित किया जाता है, इसलिए फ्री एरिना तुरंत ऑपरेटिंग सिस्टम पर वापस आ जाएगी।

मैं दो बिंदुओं पर ध्यान देना चाहता हूं:

यह पता चलता है कि नया अखाड़ा बनाते समय PyMalloc भौतिक स्मृति का 256KB आवंटित करता है।
ऑपरेटिंग सिस्टम पर केवल मुफ्त अर्नस लौटाए जाते हैं।

उदाहरण

निम्नलिखित उदाहरण पर विचार करें:

iterations = 2000000 l = [] for i in range(iterations): l.append(None) for i in range(iterations): l[i] = {} s = [] # [1] # s = l[::2] # [2] # s = l[2000000 // 2::] # [3] # s = l[::100] # [4] for i in range(iterations): l[i] = None for i in range(iterations): l[i] = {}

उदाहरण में, 2 मिलियन तत्वों की एक सूची l बनाई गई है, जो सभी किसी एक वस्तु की ओर इशारा करते हैं। अगले चक्र में, प्रत्येक तत्व के लिए एक ऑब्जेक्ट बनाया जाता है - एक खाली शब्दकोश। फिर एक दूसरी सूची बनाई जाती है, जिसके तत्व पहली सूची के कुछ तत्वों द्वारा संदर्भित कुछ वस्तुओं को इंगित करते हैं। अगले क्रॉल के बाद, सूची l से आइटम फिर से किसी भी ऑब्जेक्ट को इंगित करना शुरू करते हैं। और अंतिम चक्र में, पहली सूची से प्रत्येक तत्व के लिए फिर से शब्दकोश बनाए जाते हैं।

एस सूची विकल्प:

```
 s = [] 
```
```
 s = l[::2] 
```
```
 s = l[200000 // 2::] 
```
```
 s = l[::100] 
```

हम प्रत्येक मामले में मेमोरी खपत में रुचि रखते हैं।

हम इस स्क्रिप्ट को PyMalloc लॉगिंग सक्षम के साथ चलाएंगे:

 export PYTHONMALLOCSTATS="True" && python3 source.py 2>result.txt

परिणामों की व्याख्या

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

"इसके बिना"

पहले मामले में, सूची एस खाली है। दूसरे चक्र में वस्तुओं को बनाने के बाद, लगभग 500 एमबी मेमोरी की खपत होती है। और इन सभी वस्तुओं को तीसरे चक्र में हटा दिया जाता है, और उपयोग की गई मेमोरी ऑपरेटिंग सिस्टम में वापस आ जाती है। अंतिम चक्र में, वस्तुओं के लिए मेमोरी फिर से आवंटित की जाती है, जो उसी 500 एमबी की खपत की ओर जाता है।

"हर दिन"

मामले में जब हम सूची एल के हर दूसरे तत्व के साथ एक सूची बनाते हैं, तो हम नोटिस कर सकते हैं कि मेमोरी ऑपरेटिंग सिस्टम में वापस नहीं आती है। यही है, इस मामले में हम एक ऐसी स्थिति का निरीक्षण करते हैं जहां लगभग 250 एमबी के शब्दकोश हटाए जाते हैं, लेकिन प्रत्येक पूल में चंक्स हैं जो हटाए नहीं जाते हैं, जिसके कारण संबंधित एरेनास को जारी नहीं किया जाता है। लेकिन, जब हम दूसरी बार शब्दकोशों का निर्माण करते हैं, तो इन पूलों से मुक्त चूजों का पुन: उपयोग किया जाता है, यही वजह है कि लगभग 250 एमबी नई मेमोरी आवंटित की जाती है।

"दूसरी छमाही"

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

इस मामले में, दूसरे के विपरीत, मेमोरी आंशिक रूप से ऑपरेटिंग सिस्टम पर वापस आ जाती है। जो, एक ओर, अन्य प्रक्रियाओं को इस मेमोरी का उपयोग करने की अनुमति देता है, दूसरी ओर, सिस्टम कॉल को इसे मुफ्त और पुनः प्राप्त करने की आवश्यकता होती है।

"हर सौवां"

आखिरी मामला सबसे दिलचस्प लगता है। वहां हम पहली सूची के प्रत्येक सौवें तत्व से दूसरी सूची बनाते हैं, जिसके लिए लगभग 5MB की आवश्यकता होती है। लेकिन इस तथ्य के कारण कि प्रत्येक अखाड़े में एक निश्चित संख्या में कब्जे वाले चूजे बने हुए हैं, इस स्मृति को मुक्त नहीं किया जाता है, और खपत 500 एमबी के स्तर पर बनी हुई है। जब हम दूसरी बार शब्दकोश बनाते हैं, तो लगभग कोई नई मेमोरी आवंटित नहीं की जाती है, और जो चंक्स पहली बार आवंटित किए गए थे, उनका पुन: उपयोग किया जाता है।

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

परिणाम

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

छवियों को प्रस्तुत करने के लिए कोड

 def parse_result(filename): ms = [] with open(filename, "r") as f: for line in f: if line.startswith("Total"): m = float(line.split()[-1].replace(",", "")) / 1024 / 1024 ms.append(m) return ms ms_1 = parse_result("_1.txt") ms_2 = parse_result("_2.txt") ms_3 = parse_result("_3.txt") ms_4 = parse_result("_4.txt") import matplotlib.pyplot as plt plt.figure(figsize=(20, 15)) fontdict = { "fontsize": 20, "fontweight" : 1, } plt.subplot(2, 2, 1) plt.title(" ", fontdict=fontdict, loc="left") plt.plot(ms_1) plt.grid(b=True, which='major', color='#666666', linestyle='-.') plt.minorticks_on() plt.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2) plt.tick_params(axis='both', which='major', labelsize=15, labelbottom=False) plt.ylabel("MB", fontsize=15) plt.subplot(2, 2, 2) plt.title(" ", fontdict=fontdict, loc="left") plt.plot(ms_2) plt.grid(b=True, which='major', color='#666666', linestyle='-.') plt.minorticks_on() plt.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2) plt.tick_params(axis='both', which='major', labelsize=15, labelbottom=False) plt.ylabel("MB", fontsize=15) plt.subplot(2, 2, 3) plt.title(" ", fontdict=fontdict, loc="left") plt.plot(ms_3) plt.grid(b=True, which='major', color='#666666', linestyle='-.') plt.minorticks_on() plt.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2) plt.tick_params(axis='both', which='major', labelsize=15, labelbottom=False) plt.ylabel("MB", fontsize=15) plt.subplot(2, 2, 4) plt.title(" ", fontdict=fontdict, loc="left") plt.plot(ms_4) plt.grid(b=True, which='major', color='#666666', linestyle='-.') plt.minorticks_on() plt.grid(b=True, which='minor', color='#999999', linestyle='-', alpha=0.2) plt.tick_params(axis='both', which='major', labelsize=15, labelbottom=False) plt.ylabel("MB", fontsize=15)

पायथन मेमोरी मैनेजमेंट: मेमोरी फ्रैग्मेंटेशन के बारे में थोड़ा