एसटीएल का उपयोग इष्टतम क्यों नहीं है इसके बारे में थोड़ा सा

यह छोटा लेख इस बारे में बात करेगा कि आप कैसे और आसानी से एसटीएल लाइब्रेरी का उपयोग करके एप्लिकेशन प्रदर्शन को मार सकते हैं। इस विषय के भीतर पूरी लाइब्रेरी को कवर करना संभव नहीं है, इसलिए केवल एक घटक पर विचार किया जाएगा - एसटीडी :: स्ट्रिंग कंटेनर। एक उदाहरण के रूप में, std :: string का आरंभीकरण मूल्य दिखाया जाएगा और, परिणामस्वरूप, यह दिखाया जाएगा कि लाइब्रेरी के गैर-इष्टतम उपयोग से क्या हो सकता है। निम्न में से सभी gamedev के क्षेत्र में विशेष रूप से तीव्र है।


तो, एक उदाहरण के रूप में, चलो एक स्ट्रिंग के हैश मान की गणना करने के लिए एक आदिम फ़ंक्शन लेते हैं। मैं दो कार्यान्वयन दे दूँगा - एक सी-शैली में, दूसरा - stl- शैली का उपयोग करके std :: string। परीक्षण मामले के स्रोत कोड से लिंक करें ।

uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .

1. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
2. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
3. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
4. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
5. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
6. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
7. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
9. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
10. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
11. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
12. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
13. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .
14. uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .

uint32 hash_c( const char * str) { uint32 h = 0; const int len = strlen(str); for ( int i = 0; i < len; ++i) h = 31*h + str[i]; return h; } uint32 hash_stl( const std:: string & str) { uint32 h = 0; for (std:: string ::const_iterator it = str.begin(); it != str.end(); ++it) h = 31*h + + *it; return h; } * This source code was highlighted with Source Code Highlighter .

मैं आपको इस तथ्य पर ध्यान देने के लिए कहता हूं कि फ़ंक्शन वास्तव में स्ट्रिंग्स (कॉस्ट चार *) को पारित करेगा, इसलिए दूसरे मामले में अस्थायी ऑब्जेक्ट std :: string बनाया जाएगा। मैं दोहराता हूं, परीक्षणों का सार एसटीएल स्ट्रिंग का आरंभीकरण मूल्य दिखाना है।

अब हम कार्यों की गति को मापेंगे, परीक्षण के परिणामों की विश्वसनीयता के लिए हम 256 * 1024 पास से गणना के चक्र बनाएंगे। प्रत्येक फ़ंक्शन के लिए, प्रदर्शन को 8, 16 और 32 बाइट्स के विभिन्न लाइन आकारों पर मापा जाएगा (इसे नीचे और अधिक विवरण में वर्णित किया जाएगा)।

1. #define ITERATION_COUNT 256 * 1024
3. // ...
4. for ( int i = 0; मैं <ITERATION_COUNT; ++ i)
5. h1 = hash_c (str);
7. // ...
8. for ( int i = 0; मैं <ITERATION_COUNT; ++ i)
9. h2 = hash_stl (str);

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

नोट: उदाहरण संकलक द्वारा 2010 स्टूडियो से कमांड लाइन से संकलित किया गया था, संकलक कुंजियाँ आगे दिखाई गई हैं।

1. cl / EHsc / O2 main.cpp
3. *************************************
4. स्ट्रिंग की लंबाई: 8 बाइट्स
5. const char *: 6.20 msec, हैश: 312017024
6. std :: string : 12.62 msec, हैश: 312017024, 2.04x
8. कुल समूह: 0
10. *************************************
11. स्ट्रिंग की लंबाई: 16 बाइट्स
12. const char *: 11.78 msec, हैश: 2657714432
13. std :: string : 131.21 मिसे, हैश: 2657714432, 11.14x
15. कुल आवंटन: 262144
16. *************************************
17. स्ट्रिंग की लंबाई: 32 बाइट्स
18. const char *: 23.20 मिसे, हैश: 3820028416
19. std :: string : 144.64 msec, हैश: 3820028416, 6.24x
21. कुल आवंटन: 262144

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

यहां मस्ती शुरू होती है। परीक्षण के परिणाम बताते हैं कि प्रदर्शन में सबसे छोटी गिरावट 2 गुना है, सबसे बड़ी - 11 बार। इसी समय, 16 से अधिक बाइट्स के आकार वाली लाइनों के लिए, अतिरिक्त आवंटन ढेर पर दिखाई देते हैं। 32-बाइट लाइनों पर, गणना की पृष्ठभूमि के खिलाफ मेमोरी आवंटन लागत थोड़ा समतल है और ड्रॉडाउन थोड़ा कम है - 16-बाइट लाइनों की तुलना में लगभग 2 गुना कम है। आवंटन कहां से आते हैं?

std :: string में स्ट्रिंग को स्टोर करने के लिए अपना आंतरिक बफर होता है, जिसका आकार STL के कार्यान्वयन पर निर्भर करता है। उदाहरण के लिए, MS Visual Studio 2010 के STL कार्यान्वयन में, इस बफ़र का आकार 16 बाइट्स है, जिसे लाइब्रेरी हेडर फ़ाइलों (चर _BUF_SIZE) को देखकर देखा जा सकता है। जब std :: string को इनिशियलाइज़ किया जाता है, तो स्ट्रिंग के आकार के लिए एक चेक बनाया जाता है, और यदि यह आंतरिक बफर के आकार से छोटा होता है, तो स्ट्रिंग को इस बफर में संग्रहीत किया जाता है, अन्यथा, आवश्यक आकार की मेमोरी को हीप को आवंटित किया जाता है, और स्ट्रिंग को पहले ही कॉपी कर दिया जाता है। जैसा कि आप देख सकते हैं, हर बार std :: string को इनिशियलाइज़ किया जाता है, कम से कम डेटा कॉपी किया जाता है, साथ ही साथ उन मामलों में अतिरिक्त आबंटन किया जाता है जहाँ string का आकार std :: string आंतरिक बफर से अधिक होता है। यही कारण है कि हम रिलीज असेंबली में प्रदर्शन में एक बूंद का 11 गुना तक आवंटन का अवलोकन कर सकते हैं, जो कि मेमोरी विखंडन का कारण बनता है। अंतिम क्षण कंसोल की दुनिया में एक गंभीर समस्या है, जहां रैम की मात्रा बहुत अधिक स्थिर है और कोई वर्चुअल मेमोरी नहीं है।

अब, शायद, यह डिबग असेंबली में परीक्षा परिणाम लाने के लायक है।

1. cl / EHsc / MDd / RTC1 / ZI main.cpp
3. *************************************
4. स्ट्रिंग की लंबाई: 8 बाइट्स
5. const char *: 24.74 मिसे, हैश: 312017024
6. std :: string : 4260.18 msec, हैश: 312017024, 172.23x
8. कुल आवंटन: 262144
10. *************************************
11. स्ट्रिंग की लंबाई: 16 बाइट्स
12. const char *: 34.87 msec, हैश: 2657714432
13. std :: string : 7697.69 msec, हैश: 2657714432, 220.76x
15. कुल आवंटन: 524288
17. *************************************
18. स्ट्रिंग की लंबाई: 32 बाइट्स
19. const char *: 58.38 msec, हैश: 3820028416
20. std :: string : 14169.49 msec, हैश: 3820028416, 242.70x
22. कुल आवंटन: 524288

* इस सोर्स कोड को सोर्स कोड हाइलाइटर के साथ हाइलाइट किया गया था।

बहुत बढ़िया! ड्राडाउन प्रदर्शन महाकाव्य 240 बार! जिसकी उम्मीद की जानी है। बेशक, गंभीर स्थितियों में, आप डिबग सूचना प्रारूप c / ZI (संपादित करें और जारी रखें) को तेज़ / Zi में बदल सकते हैं, और स्टैक विफलता और अनइंस्टॉल किए गए चर (/ RTC1) के लिए विभिन्न चेक भी बंद कर सकते हैं और इस तरह बेहतर प्रदर्शन कर सकते हैं, लेकिन इस मामले में, विधानसभा डिबग का पूरा अर्थ गायब हो जाएगा।

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

अनुकूलन में शुभकामनाएँ!