🚏 ⏏️ 🍴 ऑब्जेक्ट पूल और ढेर पर वस्तुओं का तेजी से निर्माण 🤘 👩🏾‍🎨 👩‍❤️‍👩

मैं C ++ में अपनी विधानसभा की एक और बाइक साझा करना चाहता हूं। एक साइकिल वस्तुओं को जल्दी से बना और जारी कर सकती है। नतीजतन, हमें नई के साथ की तुलना में 30% तेजी से वस्तुओं को बनाने (वापस न करने) की गति मिलती है। ऑब्जेक्ट पूल कोई नई चीज नहीं है, और सामान्य रूप से - इसके बारे में बात क्यों करें। लेकिन जैसा कि वे कहते हैं - विवरण में मुख्य बात।

ऐसा हुआ कि सी ++ परियोजना में मुझे बड़ी मात्रा में छोटी वस्तुओं को ले जाना पड़ा। उन्हें क्या जरूरत थी, जैसा कि यह निकला, ढेर पर। अंतरिक्ष में स्थिति के वर्णन के अलावा ऑब्जेक्ट कुछ भी नहीं थे। और उनके पास 4x4 मैट्रिक्स टाइप डबल और कई सहायक चर थे। प्रारंभिक रूप को सरल बनाने के बाद, हम मानते हैं कि वर्ग (इस मामले में, संरचना) का रूप है:

struct Position{ double m[16]; int s; }

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

तुरंत एक आरक्षण करें जो बढ़ावा देने के साथ, और उनके जैसे अन्य लोग मुझे बहुत दूर से जानते हैं। और इसलिए, शायद मैं यहां एक साइकिल का वर्णन कर रहा हूं। फिर भी, मुझे व्यक्तिगत रूप से ऐसी बात नहीं मिली (बहुत संभावना है, इस तथ्य से कि मुझे नहीं पता कि इसे सही तरीके से कैसे कॉल किया जाए), लेकिन जो बहुत जल्दी काम करने के लिए निकला।

ऑब्जेक्ट पूल काफी प्रसिद्ध है, और सामान्य तौर पर, लागू करने के लिए एक सरल पैटर्न। ऐसा लगता है कि यह जटिल है - वस्तुओं का एक ढेर बनाएं और इसे आवश्यकतानुसार दें। जब सब कुछ सौंप दिया जाता है - अधिक बनाएँ। यदि ऑब्जेक्ट की आवश्यकता नहीं है, तो इसे हटाने के बजाय, इसे मुक्त वस्तुओं के ढेर पर लौटा दें। यहाँ एक वर्ग का उदाहरण दिया गया है जो इस पैटर्न को लागू करता है:

 template <typename T, unsigned int chunk_size = 100> class Factory { public: inline T* get(){ if(free_ptrs.empty()){ makeMore(); } T* obj = free_ptrs.back(); free_ptrs.pop_back(); return obj; } inline void free(T* obj){ free_ptrs.push_back(obj); } private: std::vector<T> buffer; std::vector<T*> free_ptrs; //   ( ,  chunk_size = 1 ).  chunk_size = 1   loop. void makeMore(){ //   vector.reserve() ,     reserve     //  vector.size() ,     .   //    STL. for (int i = 0; i < chunk_size ; ++i) { buffer.emplace_back(); //         ! free_ptrs.emplace_back(&buffer.back()); //     } } }

आवेदन:

 Factory<Position> pool; pool.get();

उपरोक्त विधि के नुकसानों पर विचार करें:
- व्यवहार में, ढेर में छोटी वस्तुओं की एक बड़ी संख्या (10,000 - 1,000,000) के निर्माण ने प्रदर्शन में महत्वपूर्ण गिरावट का कारण बना। बेशक, काम में इस तरह की ठोकरें प्रारंभिक प्रारंभिककरण के दौरान ही देखी जाएंगी। लेकिन फिर भी। अगर आप अच्छा कर सकते हैं, तो क्यों नहीं?
- बनाई गई ऑब्जेक्ट क्लास में एक डिफ़ॉल्ट कंस्ट्रक्टर होना चाहिए!
- वस्तु अपरिभाषित अवस्था में लौटती है। आप निश्चित रूप से एक निर्माता / इनिशियलाइज़र कॉल को जोड़ सकते हैं, लेकिन उस पर अधिक।

यह देखा गया था कि वस्तुओं को बहुत आसानी से देशी सरणियों में बनाया गया है:

 T* array = new T[];

और इसके द्वारा, हम वस्तुओं को समान तरीके से बनाने और संग्रहीत करने का प्रयास कर रहे हैं।
ऐसा लगता है कि यह STL'ny को बफर बनाने के लिए पर्याप्त होगा। लेकिन सरणी में प्रत्येक वृद्धि के साथ, एक नया देशी सरणी बनाया जाता है, और फिर एक टुकड़ा द्वारा अन्य सभी मौजूदा तत्वों में कॉपी / ट्रांसफर के निर्माता द्वारा बनाया जाता है। वह है - यदि हम अपनी वस्तुओं के वर्ग में स्थानांतरण निर्माता को जोड़ना नहीं चाहते हैं - तो यह बहुत धीरे-धीरे काम करेगा।
तो - इस तरह के बफ़र्स में वस्तुओं को स्टोर करने के लिए हमारे पूल को फिर से लिखें:

 template <typename T, unsigned int chunk_size = 100> class Factory { public: inline T* get(){ if(free_ptrs.empty()){ makeMore(); } T* obj = free_ptrs.back(); free_ptrs.pop_back(); return obj; } inline void free(T* obj){ free_ptrs.push_back(obj); } private: /** * @brief Use this against std::vector - because * vector have linear size complexity on reserve. * NOT grow size, but whole size! */ struct Buffer{ T* array; int size; Buffer(int num = chunk_size){ array = new T[num]; size = num; } /** * @brief IMPORTANT! Due to ussage with vector must have it. * @param other */ Buffer(Buffer&& other) noexcept{ size = other.size; array = other.array; other.array = nullptr; } ~Buffer(){ if (array != nullptr){ delete []array; } } }; std::vector<Buffer> buffers; std::vector<T*> free_ptrs; void makeMore(){ buffers.emplace_back(chunk_size); Buffer &buf = buffers.back(); for (int i = 0; i < buf.size; ++i) { free_ptrs.emplace_back(&buf.array[i]); } } };

जैसा कि आप देख सकते हैं, बफर क्लास में एक कॉपी कंस्ट्रक्टर है। हमें उन मामलों के लिए इसकी आवश्यकता होती है जब std :: वेक्टर सरणी के पुनरावृत्ति को निष्पादित करने का निर्णय लेता है।
नतीजतन, पूल का प्रारंभिक प्रारंभिककरण लगभग काफी तेज हो गया।

अंतिम स्पर्श - नई कमांड की विविधता का उपयोग करते हुए, हम बफर के लिए मेमोरी आवंटित करने की प्रक्रिया को साझा करते हैं, और वास्तव में कंस्ट्रक्टर को बुलाते हैं। जिसके परिणामस्वरूप, हमें सबसे पहले, एक "गंदा नहीं" वस्तु प्राप्त करने की अनुमति मिलती है, और दूसरी बात, यह हमें एक डिफ़ॉल्ट निर्माता के बिना वस्तुओं का उपयोग करने की अनुमति देगा।

परिणाम

 template <typename T, unsigned int chunk_size = 100> class PoolFactory { public: template<typename... Args> inline T* get(Args&&...args){ T* obj = getRaw(); new (obj) T(args...); return obj; } inline T* getRaw(){ if(free_ptrs.empty()){ makeMore(); } T* obj = free_ptrs.back(); free_ptrs.pop_back(); return obj; } inline void free(T* obj){ free_ptrs.push_back(obj); } inline void clearPool(){ buffers.clear(); free_ptrs.clear(); } void freeAll(){ free_ptrs.clear(); int buf_count = buffers.size(); for (int buf_id = 0; buf_id < buf_count; ++buf_id) { Buffer &buf = buffers[buf_id]; for (int i = 0; i < buf.size; ++i) { free_ptrs.emplace_back(&buf.array[i]); } } } private: /** * @brief Use this against std::vector - because * vector have linear size complexity on reserve. * NOT grow size, but whole size! */ struct Buffer{ T* array; int size; Buffer(int num = chunk_size){ // allocate, but not construct array = static_cast<T*> (::operator new (sizeof(T[num]))); size = num; } /** * @brief IMPORTANT! Due to ussage with vector must have it. * @param other */ Buffer(Buffer&& other) noexcept{ size = other.size; array = other.array; other.array = nullptr; } ~Buffer(){ if (array != nullptr){ // destructors for (int i = 0; i < size; ++i) { array[i].~T(); } // deallocate ::operator delete(array); } } }; std::vector<Buffer> buffers; std::vector<T*> free_ptrs; void makeMore(){ buffers.emplace_back(chunk_size); Buffer &buf = buffers.back(); for (int i = 0; i < buf.size; ++i) { free_ptrs.emplace_back(&buf.array[i]); } } };

मेरे लिए, मुख्य कार्य, इन छोटी वस्तुओं के साथ जल्दी से std :: वेक्टर को भरना था। उस से, परीक्षण कुछ विशिष्ट हैं। मेरे मामले में, पूल और emplace_back के साथ भरण समय समान है। पूल का पुन: उपयोग करते समय - स्वाभाविक रूप से पूल जीतता है।

परीक्षण

 class BaseClass { public: BaseClass(){} BaseClass(int value){ s = value; } int getS(){ return s; } int s; int m[16]; }; std::vector< BaseClass > ar; std::vector< BaseClass* > ptr_ar; const unsigned int total = 1000000; int main(int argc, char *argv[]) { PoolFactory<BaseClass> bPool; ar.reserve(total); timer.start(); for (int var = 0; var < total; ++var) { ar.emplace_back(var); } qDebug()<<"1 : "<<timer.elapsed(); ptr_ar.clear(); ptr_ar.reserve(total); timer.start(); for (int var = 0; var < total; ++var) { ptr_ar.push_back(bPool.get(var)); } qDebug()<<"2 : "<<timer.elapsed(); bPool.freeAll(); ptr_ar.clear(); ptr_ar.reserve(total); timer.start(); for (int var = 0; var < total; ++var) { ptr_ar.push_back(bPool.get(var)); } qDebug()<<"3 : "<<timer.elapsed(); ptr_ar.clear(); ptr_ar.reserve(total); timer.start(); for (int var = 0; var < total; ++var) { ptr_ar.push_back(new BaseClass(var)); } qDebug()<<"4 : "<<timer.elapsed(); }

निष्कर्ष:
1: 21
2: 22
3: 5
4: 37

बिना रिजर्व:
1: 135 (भरे जा रहे बेसक्लास क्लास में ट्रांसफर कंस्ट्रक्टर की कमी का असर है)
2: 22
3: 4
4: 38

ऑब्जेक्ट पूल और ढेर पर वस्तुओं का तेजी से निर्माण

More articles: