कंटेनर तत्वों के योग की गणना करते समय, फॉरच (Qt) और एसटीएल में से कुछ के लिए रेंज-आधारित की गति की तुलना

मैं Qt ढांचे का उपयोग करके C ++ प्रोजेक्ट विकसित करने में शामिल हूं। हमारी परियोजना में, Qt कंटेनरों का उपयोग कई स्थानों पर किया जाता है, और फ़ॉरेस्ट मैक्रो का उपयोग अक्सर तत्वों को पार करने के लिए किया जाता है। एक बिंदु पर, मैंने सोचा कि इस मैक्रो का उपयोग कितना उचित था। इसके अलावा, मैं वास्तव में एक्शन में c ++ 11 को "महसूस" करना चाहता था। और यहाँ है क्या मैं इस समय पता लगाने में कामयाब ...

सहायक लेखन

एसटीएल और क्यूटी में कंटेनरों में एक सामान्य आधार वर्ग नहीं होता है, इसलिए टेम्पलेट कार्यों के साथ प्रेषण करने का प्रयास किया गया था ताकि प्रत्येक कंटेनर के लिए एक परीक्षण फ़ंक्शन न लिखें, क्योंकि क्यूटी कंटेनर एसटीएल-शैली के पुनरावृत्तियों का समर्थन करते हैं।
फिलहाल, परीक्षण के लिए मेरा मुख्य कार्य इस तरह दिखता है:

template<typename TEST_CLASS> void runTests(int testCycles) { auto container = makeTestClass<TEST_CLASS>(); using namespace TestProcs; static auto tests = TestProcs::getRegisteredTests<TEST_CLASS>(); std::cout << "Run test for type:" << typeid(TEST_CLASS()).name() << std::endl; for (auto test : tests) { auto warmResultsTest = makeTestResults(*container, test.second, testCycles, true); std::cout << "\"" << test.first << "\" results(ms):" << getResultsString(warmResultsTest) << std::endl; } } 

TestCycles पैरामीटर एक परीक्षण की पुनरावृत्तियों की संख्या निर्धारित करता है। MakeTestClass टेम्पलेट फ़ंक्शन परीक्षण के लिए एक वर्ग का निर्माण करता है। वैक्टर के लिए, यह इस तरह दिखता है:

 template<typename TEST_CLASS> std::shared_ptr<TEST_CLASS> makeTestClass() { return std::shared_ptr < TEST_CLASS > (new TEST_CLASS(VECTOR_SIZE, 0)); } 

खैर, QList कुछ इस तरह के लिए:

 template<> std::shared_ptr<QList<TestType> > makeTestClass() { return std::shared_ptr < QList<TestType> > (new QList<TestType>( QList<TestType>::fromVector(QVector<TestType>(VECTOR_SIZE)))); } 

TestProcs :: getRegisteredTests परीक्षण के नाम और कंटेनर पर परीक्षण करने की प्रक्रिया से एक वेक्टर लौटाता है।
makeTestResults वास्तव में परीक्षण को कई बार निर्दिष्ट करता है और प्रत्येक पुनरावृत्ति के मापा निष्पादन समय के वेक्टर को लौटाता है। इन आंकड़ों के अनुसार, परीक्षण पुनरावृत्ति निष्पादन समय के औसत, न्यूनतम और अधिकतम मूल्यों पर विचार किया जाता है।

मेरे द्वारा किए गए परीक्षणों की सूची

• std :: जमना (doAccumulateTest)
• fort Qt मैक्रो (doQtForeachTest)
• सीमा-आधारित (doNewForTestt)
• STL- शैली के लिए (doSTLForTest)
• लूप के बाहर कंटेनर के अंत की गणना के साथ एसटीएल-शैली (doSTLForTest2)

 namespace TestProcs { template<typename CONTAINER> int doAccumulateTest(CONTAINER& container) { typename CONTAINER::value_type sum = typename CONTAINER::value_type(); sum = std::accumulate(container.begin(), container.end(), sum); return sum; } template<typename CONTAINER> int doQtForeachTest(CONTAINER& container) { typename CONTAINER::value_type sum = typename CONTAINER::value_type(); foreach(auto item, container) { sum += item; } return sum; } template<typename CONTAINER> int doNewForTest(CONTAINER& container) { typename CONTAINER::value_type sum = typename CONTAINER::value_type(); for (auto item : container) { sum += item; } return sum; } template<typename CONTAINER> int doSTLForTest(CONTAINER& container) { typename CONTAINER::value_type sum = typename CONTAINER::value_type(); auto it = container.begin(); for (; it != container.end(); ++it) { sum += *it; } return sum; } template<typename CONTAINER> int doSTLForTest2(CONTAINER& container) { typename CONTAINER::value_type sum = typename CONTAINER::value_type(); auto it = container.begin(); auto end = container.end(); for (; it != end; ++it) { sum += *it; } return sum; } template<typename TEST_CLASS> const std::vector<typename Typedefs<TEST_CLASS>::TestProcRecord>& getRegisteredTests() { static const std::vector<typename Typedefs<TEST_CLASS>::TestProcRecord> tests { { "New for", &doNewForTest<TEST_CLASS> }, { "Accumulate", &doAccumulateTest<TEST_CLASS> }, { "Qt foreach", &doQtForeachTest<TEST_CLASS> }, { "STL for", &doSTLForTest<TEST_CLASS> }, { "STL for 2", &doSTLForTest2<TEST_CLASS> } }; return tests; } } 

परीक्षण के परिणाम

परीक्षण किए गए कंटेनरों की सूची:

• QVector <qint32> (runTests <QVector <TestType >> (TEST_CYCLES))
• std :: वेक्टर <qint32> (रनटैस्ट <std: वेक्टर <TestType >> (TEST_CYLES))
• QList <qint32> (runTests <QList <TestType >> (TEST_CYCLES))

प्रत्येक परीक्षण के लिए पुनरावृत्तियों की संख्या = 20।
कंटेनर डेटा का आकार 30 मेगाबाइट है।
समय के अंतर से विभाजित rdtsc का उपयोग करके मापा गया था
प्रति 100,000 है।
दरअसल, परिणाम तालिका (कम मूल्य का अर्थ है तेजी से):


परिणाम तालिका के लिए डेटा का चित्रमय प्रतिनिधित्व:

परिणाम

परीक्षण कराकर मुझे अपने लिए क्या एहसास हुआ:

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

मेरी राय है कि आपको Qt प्रोजेक्ट्स में foreach मैक्रो का उपयोग करने से मना कर देना चाहिए।

आपका ध्यान देने के लिए धन्यवाद।

पुनश्च: हाँ, मुझे पता है कि आप अंतरिक्ष के बिना ">>" लिख सकते हैं।
स्रोत कोड