🧜🏼 🤱🏻 👰🏿 C ++ में मेमोरी मैनेजमेंट 🌩️ 👨🏼‍🎨 🍲

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

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

0. क्या हमें मेमोरी के साथ मैनुअल काम करने की आवश्यकता है?

सबसे पहले, हम जांच करेंगे कि एक आवंटनकर्ता स्मार्ट कैसे मेमोरी के साथ काम को गति दे सकता है।

हम C ++ और C # के लिए सरल परीक्षण लिखेंगे (C # अपने उत्कृष्ट मेमोरी मैनेजर के लिए जाना जाता है, जो पीढ़ी द्वारा वस्तुओं को विभाजित करता है, विभिन्न आकारों की वस्तुओं के लिए विभिन्न पूलों का उपयोग करता है, आदि)।

class Node { public: Node* next; }; // ... for (int i = 0; i < 10000000; i++) { Node* v = new Node(); }

 class Node { public Node next; } // ... for (int l = 0; l < 10000000; l++) { var v = new Node(); }

उदाहरण के सभी "गोलाकार वैक्यूम" के बावजूद, समय का अंतर 10 गुना (62 एमएस बनाम 650 एमएस) हो गया। इसके अलावा, सी # उदाहरण समाप्त हो गया है, और सी ++ में अच्छे टोन के नियमों के अनुसार, चयनित वस्तुओं को हटा दिया जाना चाहिए, जो अंतराल (2580 एमएस तक) को और बढ़ा देगा।

1. ऑब्जेक्ट पूल

स्पष्ट समाधान ओएस से मेमोरी का एक बड़ा ब्लॉक लेना है और इसे बराबर आकार के (नोड) ब्लॉक में विभाजित करना है, जब मेमोरी आवंटित करते हैं, तो पूल से एक ब्लॉक लेते हैं, और मुक्त होने पर, इसे पूल में लौटाते हैं। पूल को व्यवस्थित करने का सबसे आसान तरीका एक एकल लिंक की गई सूची (स्टैक) के साथ है।

चूंकि कार्यक्रम में न्यूनतम हस्तक्षेप का कार्य होता है, इसलिए यह सब किया जा सकता है कि ब्लॉकऑलोक का एक जोड़ा नोड वर्ग में जोड़ा जाए:

 class Node : public BlockAlloc<Node>

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

पेजपूल क्लास

 inline size_t align(size_t x, size_t a) { return ((x-1) | (a-1)) + 1; } //#define align(x, a) ((((x)-1) | ((a)-1)) + 1) template<size_t PageSize = 65536> class PagePool { public: void* GetPage() { void* page = VirtualAlloc(NULL, PageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); pages.push_back(page); return page; } ~PagePool() { for (vector<void*>::iterator i = pages.begin(); i != pages.end(); ++i) { VirtualFree(*i, 0, MEM_RELEASE); } } private: vector<void*> pages; };

फिर हम दिए गए आकार के ब्लॉकों का एक पूल बनाते हैं

कक्षा अवरोधक

 template<class T, size_t PageSize = 65536, size_t Alignment = 8 /* sizeof(void*) */> class BlockPool : PagePool<PageSize> { public: BlockPool() : head(NULL) { BlockSize = align(sizeof(T), Alignment); count = PageSize / BlockSize; } void* AllocBlock() { // todo: lock(this) if (!head) FormatNewPage(); void* tmp = head; head = *(void**)head; return tmp; } void FreeBlock(void* tmp) { // todo: lock(this) *(void**)tmp = head; head = tmp; } private: void* head; size_t BlockSize; size_t count; void FormatNewPage() { void* tmp = GetPage(); head = tmp; for(size_t i = 0; i < count-1; i++) { void* next = (char*)tmp + BlockSize; *(void**)tmp = next; tmp = next; } *(void**)tmp = NULL; } };

टिप्पणी // टूडू: लॉक (यह) उन स्थानों को चिह्नित करता है जिनके लिए क्रॉस-थ्रेड सिंक्रनाइज़ेशन की आवश्यकता होती है (उदाहरण के लिए, EnterCriticalSection या बढ़ावा :: mutex का उपयोग करें)।

मैं समझाता हूं कि पृष्ठ का "स्वरूपण" पूल में ब्लॉक जोड़ने के लिए फ्रीब्लॉक एब्स्ट्रैक्शन का उपयोग क्यों नहीं करता है। अगर कुछ पसंद है

 for (size_t i = 0; i < PageSize; i += BlockSize) FreeBlock((char*)tmp+i);

FIFO सिद्धांत के आधार पर उस पृष्ठ को "इसके विपरीत" चिह्नित किया जाएगा:

एक पंक्ति में पूल से अनुरोध किए गए कई ब्लॉक घटते पते होंगे। और प्रोसेसर वापस जाना पसंद नहीं करता है, इससे वह प्रीफच ( UPD : आधुनिक प्रोसेसर के लिए प्रासंगिक नहीं) टूट जाता है। यदि आप मार्कअप को लूप में करते हैं

 for (size_t i = PageSize-(BlockSize-(PageSize%BlockSize)); i != 0; i -= BlockSize) FreeBlock...

तब मार्कअप लूप वापस पतों पर जाएगा।

अब जब तैयारी की जाती है, तो हम अशुद्धता वर्ग का वर्णन कर सकते हैं।

 template<class T> class BlockAlloc { public: static void* operator new(size_t s) { if (s != sizeof(T)) { return ::operator new(s); } return pool.AllocBlock(); } static void operator delete(void* m, size_t s) { if (s != sizeof(T)) { ::operator delete(m); } else if (m != NULL) { pool.FreeBlock(m); } } // todo: implement nothrow_t overloads, according to borisko' comment // http://habrahabr.ru/post/148657/#comment_5020297 // Avoid hiding placement new that's needed by the stl containers... static void* operator new(size_t, void* m) { return m; } // ...and the warning about missing placement delete... static void operator delete(void*, void*) { } private: static BlockPool<T> pool; }; template<class T> BlockPool<T> BlockAlloc<T>::pool;

मैं समझाऊंगा कि क्यों (s! = Sizeof (T)) चेक की जरूरत है
वे कब आग लगाते हैं? तब, जब आधार T से विरासत में मिली एक क्लास बनाई / डिलीट की जाती है।
वारिस सामान्य रूप से नए / डिलीट का उपयोग करेंगे, लेकिन उनमें ब्लॉकऑलोक को भी जोड़ा जा सकता है। इस प्रकार, हम आसानी से और सुरक्षित रूप से यह निर्धारित करते हैं कि कार्यक्रम में कुछ तोड़ने के डर के बिना किन वर्गों को पूल का उपयोग करना चाहिए। मल्टीपल इनहेरिटेंस भी इस प्रवेश के साथ बढ़िया काम करता है।

हो गया। BlockAlloc Node और retest को इनहेरिट करें।
परीक्षा का समय अब 120 मि। 5 बार तेजी से। लेकिन सी # में, एक आवंटनकर्ता अभी भी बेहतर है। संभवतः एक लिंक की गई सूची नहीं है। (यदि हम नए के तुरंत बाद डिलीट को तुरंत कॉल करते हैं, और इस तरह कैश में डेटा डालने में बहुत अधिक मेमोरी बर्बाद नहीं करते हैं, तो हमें 62 एमएस मिलेंगे। अजीब। .NET सीएलआर की तरह, जैसे कि यह फ्री-अप लोकल वैरिएबल्स को तुरंत संबंधित पूल में लौटाता है, जीसी के इंतजार के बिना)

2. कंटेनर और उसके रंगीन सामग्री

क्या आप अक्सर उन कक्षाओं में आते हैं जो अपने आप में बहुत सी अलग-अलग बाल वस्तुओं को संग्रहीत करते हैं, जैसे कि उत्तरार्द्ध का जीवनकाल माता-पिता के जीवनकाल से अधिक लंबा नहीं है?

उदाहरण के लिए, यह एक XmlDocument वर्ग हो सकता है जो नोड और गुण वर्गों से भरा होता है, साथ ही नोड्स के अंदर पाठ से ली गई सी-लाइन्स (चार *) भी होती है। या फ़ाइल प्रबंधक में फ़ाइलों और निर्देशिकाओं की एक सूची जो निर्देशिका को फिर से पढ़ने और अब बदलने पर लोड होती है।

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

आइए PointerBumpAllocator क्लास बनाएं, जो एक बड़े ब्लॉक से अलग-अलग आकार के टुकड़े काट सकता है और पुराने के समाप्त होने पर एक नया बड़ा ब्लॉक आवंटित कर सकता है।

PointerBumpAllocator वर्ग

 template<size_t PageSize = 65536, size_t Alignment = 8 /* sizeof(void*) */> class PointerBumpAllocator { public: PointerBumpAllocator() : free(0) { } void* AllocBlock(size_t block) { // todo: lock(this) block = align(block, Alignment); if (block > free) { free = align(block, PageSize); head = GetPage(free); } void* tmp = head; head = (char*)head + block; free -= block; return tmp; } ~PointerBumpAllocator() { for (vector<void*>::iterator i = pages.begin(); i != pages.end(); ++i) { VirtualFree(*i, 0, MEM_RELEASE); } } private: void* GetPage(size_t size) { void* page = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); pages.push_back(page); return page; } vector<void*> pages; void* head; size_t free; }; typedef PointerBumpAllocator<> DefaultAllocator;

अंत में, हम ओवरलोड नए के साथ चाइल्डऑब्जेक्ट के एक प्रवेश का वर्णन करते हैं और दिए गए आवंटन को एक्सेस करते हुए हटाते हैं:

 template<class T, class A = DefaultAllocator> struct ChildObject { static void* operator new(size_t s, A& allocator) { return allocator.AllocBlock(s); } static void* operator new(size_t s, A* allocator) { return allocator->AllocBlock(s); } static void operator delete(void*, size_t) { } // *1 static void operator delete(void*, A*) { } static void operator delete(void*, A&) { } private: static void* operator new(size_t s); };

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

नया (... ऑपरेटर के लिए पैरामीटर ...) चाइल्डऑबजेक्ट (... कंस्ट्रक्टर पैरामीटर ...)

सुविधा के लिए, मैंने दो नए ऑपरेटरों को परिभाषित किया जो A & A * को स्वीकार करते हैं।
यदि एक आवंटनकर्ता को सदस्य के रूप में मूल वर्ग में जोड़ा जाता है, तो पहला विकल्प अधिक सुविधाजनक होता है:

 node = new(allocator) XmlNode(nodename);

यदि एक आवंटनकर्ता को पूर्वज (अशुद्धता) के रूप में जोड़ा जाता है, तो दूसरा अधिक सुविधाजनक होता है:

 node = new(this) XmlNode(nodename);

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

कॉल हटाने के लिए कोई विशेष वाक्यविन्यास नहीं है; संकलक मानक डिलीट (* 1 चिह्नित) को कॉल करेगा, भले ही नए ऑपरेटरों का उपयोग ऑब्जेक्ट बनाने के लिए किया गया था। अर्थात, डिलीट सिंटैक्स सामान्य है:

 delete node;

यदि चाइल्डऑबजेक्ट (या उसके उत्तराधिकारी) के निर्माण में कोई अपवाद होता है, तो इस ऑब्जेक्ट को बनाते समय उपयोग किए गए नए ऑपरेटर के हस्ताक्षर के अनुरूप हटाएं को कहा जाता है (पहले पैरामीटर size_t को void * के साथ बदल दिया जाएगा)।

नए ऑपरेटर को निजी अनुभाग में रखने से आवंटनकर्ता को निर्दिष्ट किए बिना नए कॉल करने से बचाता है।

यहां एलोकेटर-चाइल्डऑब्जेक्ट जोड़ी का उपयोग करने का एक पूरा उदाहरण है:

उदाहरण

 class XmlDocument : public DefaultAllocator { public: ~XmlDocument() { for (vector<XmlNode*>::iterator i = nodes.begin(); i != nodes.end(); ++i) { delete (*i); } } void AddNode(char* content, char* name) { char* c = (char*)AllocBlock(strlen(content)+1); strcpy(c, content); char* n = (char*)AllocBlock(strlen(name)+1); strcpy(n, content); nodes.push_back(new(this) XmlNode(c, n)); } class XmlNode : public ChildObject<XmlNode, XmlDocument> { public: XmlNode(char* _content, char* _name) : content(_content), name(_name) { } private: char* content; char* name; }; private: vector<XmlNode*> nodes; };

निष्कर्ष। सैंडबॉक्स के लिए लेख 1.5 साल पहले लिखा गया था, लेकिन अफसोस, मॉडरेटर को यह पसंद नहीं आया।

C ++ में मेमोरी मैनेजमेंट

0. क्या हमें मेमोरी के साथ मैनुअल काम करने की आवश्यकता है?

1. ऑब्जेक्ट पूल

2. कंटेनर और उसके रंगीन सामग्री

More articles: