QThreads CPU कोर नहीं ठीक से उपयोग उपयोग किया

Question

का उपयोग करना: C++ (MinGW), Qt4.7.4, Vista (OS), intel core2vPro

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

QThread* ptrThread1=new QThread; 
QThread* ptrThread2=new QThread; 
ProcessTimeConsuming* ptrPTC1=new ProcessTimeConsuming(); 
ProcessTimeConsuming* ptrPTC2=new ProcessTimeConsuming(); 

ptrPTC1->moveToThread(ptrThread1); 
ptrPTC2->moveToThread(ptrThread2); 

//make connections to specify what to do when processing ends, threads terminate etc 
//display some label to give an idea that the code is in execution 

ptrThread1->start(); 
ptrThread2->start(); //i want this thread to be executed in the core other than the one used above 

ptrQApplication->exec(); //GUI event loop for label display and signal-slot monitoring 

Answer 1

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

आम तौर पर, आप अनुक्रम में फ़ाइलों को पढ़ने से बेहतर नहीं कर सकते हैं और फिर उन्हें निर्माता-उपभोक्ता मॉडल का उपयोग करके समानांतर में संसाधित कर सकते हैं।

Answer 2

मैंने सोचा कि मेरे अनुभवजन्य डेटा इस चर्चा के लिए कुछ उपयोग हो सकते हैं। मेरे पास 980 txt फ़ाइलों वाली निर्देशिका है जिसे मैं पढ़ना चाहता हूं। क्यूटी/सी ++ ढांचे में और इंटेल i5 क्वाड कोर पर चलने पर, मैंने एक जीयूआई एप्लीकेशन बनाया और एक पथ कार्यकर्ता को अपना रास्ता दिया गया फ़ाइल पढ़ने के लिए जोड़ा। मैंने कार्यकर्ता को थ्रेड में धक्का दिया, फिर प्रत्येक रन को अतिरिक्त थ्रेड जोड़ना दोहराया। मैंने 1 थ्रेड के साथ लगभग 13 मिनट, 2 मिनट के साथ 9 मिनट और 8 मिनट के साथ समय लगाया। इसलिए, मेरे मामले में कुछ लाभ था, लेकिन यह जल्दी से गिरावट आई।

Answer 3

मैकेनिकल हार्ड ड्राइव के साथ, आपको अनुक्रमिक पाठ बनाम समय व्यतीत करने में व्यतीत समय के अनुपात को स्पष्ट रूप से नियंत्रित करने की आवश्यकता है। ऐसा करने का कैननिकल तरीका एन + एम ऑब्जेक्ट m+min(n, QThread::idealThreadCount()) थ्रेड पर चल रहा है। यहां, मीटर फ़ाइलों की हार्ड ड्राइव की संख्या है, और n फ़ाइलों की संख्या है।

• मीटर वस्तुओं में से प्रत्येक एक राउंड रोबिन फैशन में दिए गए हार्ड ड्राइव से फ़ाइलों पढ़ रहा है। प्रत्येक पढ़ना पर्याप्त रूप से बड़ा होना चाहिए। आधुनिक हार्ड ड्राइव पर, चलो बैंडविड्थ का बजट 70 एमबाइट्स/एस (वास्तविक मूल्य का बेंचमार्क कर सकते हैं), 5 एमएमएस तलाश के लिए। बैंडविड्थ के अधिकांश 10% पर बर्बाद करने के लिए, आपके पास केवल 100ms या 100ms/(5ms/seek) = 20 प्रति सेकेंड की तलाश है। इस प्रकार आपको अगली फ़ाइल से पढ़ने से पहले प्रत्येक फ़ाइल से कम से कम 70 एमबाइट्स/(20seeks + 1) = 3.3 मेगाबाइट्स को पढ़ना होगा। यह धागा फ़ाइल डेटा के साथ एक बफर भरता है, और बफर तब प्रासंगिक गणना गणना को इंगित करता है जो बफर के दूसरी तरफ से जुड़ा होता है। जब एक बफर व्यस्त होता है, तो आप बस तब तक फ़ाइल से पढ़ना छोड़ देते हैं जब तक कि बफर फिर से उपलब्ध न हो जाए।

• अन्य एन ऑब्जेक्ट्स गणना गणना वस्तुएं हैं, वे एक बफर से सिग्नल पर गणना करते हैं जो इंगित करता है कि बफर भरा हुआ है। जैसे ही बफर डेटा की आवश्यकता नहीं होती है, बफर "रीसेट" होता है ताकि फ़ाइल रीडर इसे फिर से भर सके।

सभी पाठक वस्तुओं को अपने स्वयं के धागे की आवश्यकता होती है। गणना वस्तुओं को अपने स्वयं के धागे के बीच एक राउंड-रॉबिन फैशन में वितरित किया जा सकता है, ताकि सभी धागे +1 के भीतर हों, -0 एक-दूसरे की वस्तुएं।