दिलचस्प पोस्ट
जावास्क्रिप्ट का उपयोग करके एक्सल के लिए एचटीएमएल टेबल को कैसे निर्यात करें कश्मीर के बराबर क्लस्टर आकार के साथ एल्गोरिथ्म भिन्नता का मतलब है एक स्थिर सरणी के आकार को चर क्यों नहीं बनाया जा सकता? स्प्रिंग बूट कई डेटा स्रोत उस वसंत से बचने के लिए आइडिया। हेंडलर / स्प्रिंग.schemas एक जार में कई वसंत निर्भरताओं को मिलाते समय अधिलेखित हो जाते हैं रिंगटोन के रूप में ऑडियो फाइल सेट करना शेष चौड़ाई लेने के लिए एक div का विस्तार करें Jquery ट्रिगर फ़ाइल इनपुट C ++ फ़ंक्शन पॉइंटर प्रकार के रूप में कक्षा विधि का उपयोग करना क्या मैं उसी मशीन पर Google Chrome के कई संस्करण चला सकता हूँ? (मैक या विंडोज) मैं अपने सी # एप्लिकेशन के साथ एक फ़ॉन्ट कैसे जोड़ूं? (विजुअल स्टूडियो 2005 का प्रयोग) एंड्रॉइड सिक्वेट स्टोर करें SciPy 2D बहुभुज मास्क बनाएँ स्ट्रीम दो बार पढ़ें Websocket सर्वर: वेब सॉकेट पर ओपन फ़ंक्शन पर कभी भी कॉल नहीं किया जाता है

क्या हेक स्टडी :: डेक के स्मृति ओवरहेड के साथ चल रहा है?

मैं एक बाहरी सॉर्टिंग एल्गोरिथ्म पर काम कर रहा हूं जो std::queue का उपयोग करता है और उसकी मेमोरी उपयोग को ध्यान से रोकना चाहिए। मैंने देखा है कि मर्ज चरण के दौरान (जो निश्चित अवधि के कई std::queue का उपयोग करता है), मेरी स्मृति का उपयोग लगभग 2.5X तक बढ़ जाता है जो मुझे उम्मीद थी चूंकि std::queue डिफ़ॉल्ट रूप से std::deque का उपयोग अपने अंतर्निहित कंटेनर के रूप में करता है, इसलिए मैंने अपनी स्मृति ओवरहेड निर्धारित करने के लिए std::deque पर कुछ परीक्षण चलाया। 64-बिट प्रक्रिया के साथ, रिलीज़ मोड में, वीसी ++ 9 पर चल रहे परिणाम यहां दिए गए हैं:

एक std::deque लिए 100,000,000 char को std::deque , मेमोरी उपयोग 252,216 के लिए बढ़ता है। ध्यान दें कि 100 एम char एस (1 बाइट) को 97,656K पर कब्जा करना चाहिए, इसलिए यह 154,560 क्यू का ओवरहेड है

मैंने double एस (8 बाइट्स) के साथ टेस्ट दोहराई और देखा कि मेमोरी 1,976,676 किलो तक बढ़ती है, जबकि 100 एम double एस को 1,1 9, 546 के ओवरहेड के लिए 781,250 किलो पर कब्जा करना चाहिए !!

अब मैं समझता हूं कि std::deque को आमतौर पर "खंड" की एक लिंक्ड सूची के रूप में लागू किया जाता है। यदि यह सत्य है, तो तत्व आकार के लिए आनुपातिक क्यों आनुपातिक है (निश्चित रूप से सूचक आकार 8 बाइट्स पर तय किया जाना चाहिए)? और क्यों यह इतना विशाल danged है?

कोई भी क्यों कुछ std::deque इतना danged स्मृति का उपयोग करता है पर कुछ प्रकाश डाला सकता है? मुझे लगता है कि मुझे std::vector को std::vector लिए अंतर्निहित कंटेनरों पर स्विच करना चाहिए क्योंकि कोई ओवरहेड नहीं है (यह कि उचित आकार reserve )। मैं std::deque के लाभों पर विचार कर रहा हूं इस तथ्य से बड़े पैमाने पर नकार दिया गया है कि इसकी इतनी बड़ी उपरि है (जिसके परिणामस्वरूप कैश की याद हो जाती है, पृष्ठ दोष, आदि), और std::vector तत्वों की नकल की लागत कम है, यह देखते हुए कि समग्र स्मृति उपयोग बहुत कम है क्या यह माइक्रोसॉफ्ट द्वारा std::deque का सिर्फ एक बुरा कार्यान्वयन है?

Solutions Collecting From Web of "क्या हेक स्टडी :: डेक के स्मृति ओवरहेड के साथ चल रहा है?"

_DEQUESIZ के लिए कोड देखें (ब्लॉक प्रति तत्वों की संख्या):

 #define _DEQUESIZ (sizeof (_Ty) <= 1 ? 16 \ : sizeof (_Ty) <= 2 ? 8 \ : sizeof (_Ty) <= 4 ? 4 \ : sizeof (_Ty) <= 8 ? 2 : 1) /* elements per block (a power of 2) */ 

यदि तत्व बड़ा होता है तो यह छोटा हो जाता है। केवल 8 बाइट्स से बड़ा तत्वों के लिए आपको अपेक्षित व्यवहार (तत्व आकार की वृद्धि के साथ ओवरहेड की प्रतिशत कमी) मिलेगा।

क्या यह संभव है कि आप डिबग बायनेरिज़ चला रहे हैं? 100 एम अक्षरों के लिए 252 एमबी बहुत पसंद हैं …

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

संपादित करें: एफवाईआई – जब मैं वी.एस. 2010 पर डिबगर के बाहर चलाता हूं तो मुझे 181 एमबी मिलते हैं जिसमें char एस एस होते हैं।

 deque<char> mydequeue; for (size_t i = 0; i < 100 * 1024 * 1024; ++i) { mydequeue.push_back(char(i)); } 

संपादित करें: डायलेक्टिकस से दूसरे उत्तर का समर्थन करने से, यह मुझे उसी पदचिह्न को double :

 struct twoInt64s { public: twoInt64s(__int64 _a, __int64 _b) : a(_a), b(_b) {} __int64 a; __int64 b; }; 

संपादित करें: दिखाया गया है (128 वर्ण प्रति ब्लॉक) के रूप में संशोधित _DEQUESIZ साथ, 100 एम अक्षरों को अब स्मृति का 113 एम लेता है

मेरा निष्कर्ष यह है कि शेष ओवरहेड आपको deque ब्लॉकों के लिए प्रबंधन संरचनाओं की वजह से है, जिसमें डेटा के 16 अक्षर हैं, साथ ही deque लिए नियंत्रण जानकारी और हेप मैनेजर के लिए अधिक नियंत्रण जानकारी।

 #define _DEQUESIZ (sizeof (value_type) <= 1 ? 128 \ : sizeof (value_type) <= 2 ? 8 \ : sizeof (value_type) <= 4 ? 4 \ : sizeof (value_type) <= 8 ? 2 \ : 1) /* elements per block (a power of 2) */ 

नैतिक – यदि आप वास्तव में अपने विशेष उद्देश्य के लिए इसे अनुकूलित करना चाहते हैं, तो <deque> साथ खेलने के लिए तैयार रहें। इसका व्यवहार आपके तत्वों के आकार पर गंभीर रूप से निर्भर करता है, और इसके अलावा अपेक्षित उपयोग पैटर्न पर।

संपादित करें: आपके कतार आकार के ज्ञान के आधार पर, आप std :: queue कंटेनर के प्रतिस्थापन के रूप में boost :: circular_buffer को छोड़ सकते हैं। मुझे यह शर्त है कि आप चाहते हैं जितना अधिक प्रदर्शन करेंगे (और अपेक्षित)।

Std :: queue के वास्तविक कार्यान्वयन को देखने के बिना, मेरा अनुमान है कि इसकी स्मृति आवंटन कुछ ऐसा दिखता है:

 if (new element won't fit) { double the size of the backing storage realloc the buffer (which will probably copy all elements) } 

अधिक रूढ़िवादी होने की बजाय दोहरीकरण का कारण यह है कि आप चाहते हैं कि queue.push_pack ऑपरेशन को ओ (1) औसत समय चूंकि पुनर्गठन मौजूदा तत्वों की प्रतिलिपि बना सकता है, वही संस्करण जो कि जरूरत के मुताबिक सरणी में वृद्धि करता है (1 समय में एक तत्व) ओ (एन ^ 2) होगा क्योंकि आप शुरू में कतार में अपने सभी मानों को धक्का देते हैं मैं इसे रीडर के लिए एक अभ्यास के रूप में छोड़ दूँगा कि कैसे दोगुना संस्करण लगातार औसत समय देता है।

चूंकि आप संपूर्ण प्रक्रिया का आकार उद्धृत कर रहे हैं, जब आप 2 (2 ^ 26 <100 एमएम <2 ^ 27) तत्वों के मूल्य की तुलना में थोड़ी अधिक धक्का लगते हैं तो लगभग 2x ओवरहेड का अनुमान उचित लगता है। 2 ^ (एन -1) पर रोकने की कोशिश करें, मापने, फिर कुछ तत्वों को दबाएं और फिर से मापें।