वेक्टर

Question

के लिए समांतर योग कृपया कोई सुझाव दे सकता है कि मैं मल्टीथ्रेडिंग के माध्यम से लूप के रनटाइम के लिए निम्न को कैसे कम कर सकता हूं? मान लीजिए कि मेरे पास 'ए' और 'बी' नामक दो वैक्टर भी हैं।

for (int j = 0; j < 8000; j++){ 
    // Perform an operation and store in the vector 'a' 
    // Add 'a' to 'b' coefficient wise 
} 

लूप के लिए यह मेरे कार्यक्रम में कई बार निष्पादित किया जाता है। उपरोक्त लूप में दो ऑपरेशन पहले ही अनुकूलित किए गए हैं, लेकिन वे केवल एक कोर पर चलते हैं। हालांकि, मेरे पास 16 कोर उपलब्ध हैं और उनका उपयोग करना चाहते हैं।

मैंने निम्नानुसार लूप को संशोधित करने का प्रयास किया है। वेक्टर 'ए' रखने के बजाय, मेरे पास 16 वैक्टर हैं, और मान लीजिए कि i-th को एक [i] कहा जाता है। मेरे लिए पाश अब लग रहा है

तरह

for (int j = 0; j < 500; j++){ 
    for (int i = 0; i < 16; i++){ 
     // Perform an operation and store in the vector 'a[i]' 
    } 
    for (int i = 0; i < 16; i++){ 
     // Add 'a[i]' to 'b' coefficient wise 
    } 

} 

मैं OpenMP में से प्रत्येक पर छोरों के लिए अंदर 'के लिए #pragma omp समानांतर' जोड़कर का उपयोग आंतरिक छोरों से प्रत्येक से पहले। मेरे सभी प्रोसेसर उपयोग में हैं लेकिन मेरा रनटाइम केवल महत्वपूर्ण रूप से बढ़ता है। क्या किसी के पास इस लूप के रनटाइम को कम करने के बारे में कोई सुझाव है? पहले ही, आपका बहुत धन्यवाद।

Answer 1

omp आपके प्रोग्राम व्हीवर के लिए थ्रेड बनाता है जो आप प्रगा टैग डालते हैं, इसलिए यह आंतरिक टैग के लिए थ्रेड बना रहा है लेकिन समस्या 16 धागे बनाई गई है, प्रत्येक एक 1 ऑपरेशन करता है और फिर उन सभी को आपकी विधि का उपयोग करके नष्ट कर दिया जाता है। थ्रेड बनाने और नष्ट करने में काफी समय लगता है, इसलिए आपके द्वारा उपयोग की जाने वाली विधि आपकी प्रक्रिया के अत्यधिक समय को बढ़ाती है हालांकि यह सभी 16 कोर का उपयोग करती है। आपको अपने 8000 लूप से पहले #pragma omp parallel for टैग डालने के लिए आंतरिक फोर्स बनाने की ज़रूरत नहीं थी, यह ट्रेड के बीच अलग-अलग मूल्यों के लिए ओंप तक है, इसलिए आपने दूसरा लूप बनाने के लिए क्या किया है, ओएमपी का काम है। कि जिस तरह से omp केवल एक बार धागे बनाने और उसके बाद 500 प्रत्येक थ्रेड कि का उपयोग संख्या की प्रक्रिया और उसके बाद (का उपयोग कर 499 कम धागा निर्माण और विनाश) उन सभी को खत्म

Answer 2

Does anyone have any suggestions on how I can decrease the runtime of this loop?

for (int j = 0; j < 500; j++){ // outer loop 
    for (int i = 0; i < 16; i++){ // inner loop 

हमेशा बाहरी बनाने की कोशिश लूपआंतरिक लूप से कम पुनरावृत्तियों। यह आपको आंतरिक लूप प्रारंभिक से कई बार बचाएगा। उपरोक्त कोड में आंतरिक लूप i = 0;500 बार प्रारंभ किया गया है। अब,

for (int i = 0; j < 16; i++){ // outer loop 
    for (int j = 0; j < 500; j++){ // inner loop 

अब, भीतरी पाश j = 0; केवल 16 बार आरंभ नहीं हो जाता! तदनुसार अपना कोड संशोधित करने का प्रयास करें, अगर इससे कोई प्रभाव पड़ता है।

Answer 3

दरअसल, मैं इन टिप्पणियों को एक उत्तर में डाल रहा हूं।

तुच्छ संचालन के लिए फोर्जिंग थ्रेड केवल ओवरहेड जोड़ता है।

सबसे पहले, सुनिश्चित करें कि आपका कंपाइलर आपके लूप को लागू करने के लिए वेक्टर निर्देशों का उपयोग कर रहा है। (यदि यह नहीं जानता कि यह कैसे करना है, तो आपको स्वयं वेक्टर निर्देशों के साथ कोड करना पड़ सकता है; "एसएसई इंस्ट्रिनिक्स" की खोज करने का प्रयास करें। लेकिन इस तरह के वैक्टरों के सरल जोड़ के लिए, स्वचालित वेक्टरेशन संभव होना चाहिए।)

gcc -O3 -march=native ... 

पता लगाने के लिए किया जाए या नहीं यह अपने पाश और क्यों ऑटो vectorized -ftree-vectorizer-verbose=2 जोड़ें:

अपने संकलक मान लिया जाये साथ यह आह्वान एक यथोचित आधुनिक जीसीसी है।

यदि आप पहले ही वेक्टर निर्देशों का उपयोग कर रहे हैं, तो यह संभव है कि आप अपनी मेमोरी बैंडविड्थ को संतृप्त कर रहे हों। आधुनिक सीपीयू कोर बहुत तेज हैं ... यदि हां, तो आपको लूप के प्रत्येक पुनरावृत्ति के अंदर अधिक संचालन करने के लिए उच्च स्तर पर पुनर्गठन करने की आवश्यकता है, एल 1 कैश के अंदर फिट होने वाले ब्लॉकों पर बहुत से संचालन करने के तरीके ढूंढ रहे हैं।