omp समानांतर बनाम omp समानांतर

Question

इन दोनों के बीच क्या अंतर है?

[ए]

#pragma omp parallel
{ 
    #pragma omp for
    for(int i = 1; i < 100; ++i)
    {
        ...
    }
}

[बी]

#pragma omp parallel for
for(int i = 1; i < 100; ++i)
{
   ...
}

Answer 1

मुझे नहीं लगता कि कोई अंतर है, एक दूसरे के लिए एक शॉर्टकट है। यद्यपि आपका सटीक कार्यान्वयन उनके साथ अलग तरीके से व्यवहार कर सकता है।

संयुक्त समानांतर वर्कशीट निर्माण एक समानांतर निर्माण को निर्दिष्ट करने के लिए एक शॉर्टकट है जिसमें एक वर्कशेयर निर्माण और कोई अन्य कथन नहीं है। अनुमत क्लॉज समानांतर और वर्कश्रिंग कंट्रोल्स के लिए अनुमति दिए गए क्लॉज का संघ हैं।

Http://www.openmp.org/mp-documents/OpenMP3.0-SummarySpec.pdf से लिया गया

OpenMP के लिए चश्मा यहाँ हैं:

https://openmp.org/specifications/

Answer 2

ये बराबर हैं।

#pragma omp parallelस्प्रेड थ्रेड्स के #pragma omp forबीच लूप पुनरावृत्तियों को विभाजित करते हुए, थ्रेड्स के एक समूह को जन्म देता है। आप दोनों चीजों को एक साथ जुड़े हुए #pragma omp parallel forनिर्देश के साथ कर सकते हैं ।

Comments

अपने कोड में मैं इस संरचना का उपयोग कर रहा हूं। हालांकि जब मैं schedule(static, chunk)निर्देश के लिए क्लॉज का उपयोग करता हूं , तो मुझे एक समस्या आती है। कोड ठीक चलता है, लेकिन जब मैं एक MPI प्रोग्राम से इस कोड को लागू कर रहा हूं तो यह एक अनंत लूप में चलता है। इस लूप के सभी पुनरावृत्तियों में लूप काउंटर शून्य है। मेरे पास #pragma omp parallelनिर्देश में निजी के रूप में परिभाषित लूप काउंटर है । पता नहीं क्यों यह केवल तब विफल हो जाता है जब एमपीआई कोड को लागू कर रहा हो। मुझे कुछ यकीन है कि प्रत्येक MPI प्रक्रिया क्लस्टर के एक अलग प्रोसेसर पर चल रही है अगर यह मायने रखता है। कोई विचार नहीं है अगर शेड्यूल समस्या पैदा कर रहा है।

— रोहित बंगा

जब मैं #pragma omp parallel forनिर्देश का उपयोग करता हूं तो वही काम ठीक रहता है । वहाँ कुछ अंतर होना चाहिए।

— रोहित बंगा

अद्यतन: जैसा कि यह पता चला है, मैं केवल इस समस्या का अवलोकन कर रहा हूं जब मैं शेड्यूल क्लॉज का उपयोग करता हूं, तो मुझे लगता है कि यह इस पर निर्भर नहीं है कि मैं संयुक्त समानांतर का उपयोग करता हूं या दो अलग-अलग निर्देशों के लिए।

— रोहित बंगा

Answer 3

यहाँ अलग parallelऔर for यहाँ का उपयोग करने का उदाहरण है । संक्षेप में इसका उपयोग forकई थ्रेड्स में चक्र को निष्पादित करने से पहले OpenMP थ्रेड-प्राइवेट सरणियों के गतिशील आवंटन के लिए किया जा सकता है । में एक ही प्रारंभिक करना असंभव हैparallel forमामले ।

यूपीडी: प्रश्न उदाहरण में, एकल प्रज्ञा और दो प्रैग्मस के बीच कोई अंतर नहीं है। लेकिन व्यवहार में आप अलग-अलग समानांतर और निर्देशों के साथ अधिक थ्रेड जागरूक व्यवहार कर सकते हैं। उदाहरण के लिए कुछ कोड:

#pragma omp parallel
{ 
    double *data = (double*)malloc(...); // this data is thread private

    #pragma omp for
    for(1...100) // first parallelized cycle
    {
    }

    #pragma omp single 
    {} // make some single thread processing

    #pragma omp for // second parallelized cycle
    for(1...100)
    {
    }

    #pragma omp single 
    {} // make some single thread processing again

    free(data); // free thread private data
}

Answer 4

यद्यपि विशिष्ट उदाहरण के दोनों संस्करण समतुल्य हैं, जैसा कि पहले से ही अन्य उत्तरों में बताया गया है, उनके बीच अभी भी एक छोटा अंतर है। पहले संस्करण में एक अनावश्यक अंतर्निहित बाधा शामिल है, जो "ओम्पी के लिए" के अंत में सामने आई है। अन्य अंतर्निहित बाधा समानांतर क्षेत्र के अंत में पाई जा सकती है। "Nowait" को "omp for" में जोड़ने से दो कोड समान होंगे, जो कम से कम एक OpenMP परिप्रेक्ष्य से होगा। मैं इसका उल्लेख करता हूं क्योंकि एक OpenMP संकलक दो मामलों के लिए थोड़ा अलग कोड उत्पन्न कर सकता है।

Answer 5

जब मैं g ++ 4.7.0 में लूप के लिए और उपयोग कर रहा हूं तो मैं अलग-अलग रनटाइम देख रहा हूं

std::vector<double> x;
std::vector<double> y;
std::vector<double> prod;

for (int i = 0; i < 5000000; i++)
{
   double r1 = ((double)rand() / double(RAND_MAX)) * 5;
   double r2 = ((double)rand() / double(RAND_MAX)) * 5;
   x.push_back(r1);
   y.push_back(r2);
}

int sz = x.size();

#pragma omp parallel for

for (int i = 0; i< sz; i++)
   prod[i] = x[i] * y[i];

सीरियल कोड (नहीं openmp) 79 एमएस में चलता है। "समानांतर के लिए" कोड 29 एमएस में चलता है। अगर मैं चूकता हूं forऔर उपयोग करता हूं#pragma omp parallel , तो रनटाइम 179ms तक शूट हो जाता है, जो सीरियल कोड की तुलना में धीमा है। (मशीन में 8 की hw संगामिति है)

कोड लिंक करता है libgomp

Comments

मुझे लगता है कि यह इसलिए है क्योंकि omp समानांतर धागे में लूप को थ्रेड में विभाजित किए बिना निष्पादित करता है, इसलिए मुख्य धागा दूसरे थ्रेड के समाप्त होने की प्रतीक्षा कर रहा है। और समय सिंक्रनाइज़ करने पर खर्च करता है।

— एंटीग्लुक

ऐसा इसलिए है क्योंकि बिना #pragma omp forलूप के कोई मल्टी-थ्रेडेड शेयरिंग नहीं है। लेकिन यह वैसे भी ओपी मामला नहीं था, फिर से #pragma omp forअंदर एक अतिरिक्त के साथ प्रयास करें #pragm omp parallelऔर इसे #pragma omp parallel forसंस्करण की तरह ही (यदि समान नहीं है) चलाना चाहिए ।

— क्रिश्चियन राउ

मैं इस उत्तर को सर्वश्रेष्ठ के रूप में देखता हूं क्योंकि यह दिखाता है कि वे "समकक्ष" नहीं हैं

— असफल वैज्ञानिक

Answer 6

स्पष्ट रूप से बहुत सारे उत्तर हैं, लेकिन यह एक बहुत अच्छी तरह से उत्तर देता है (स्रोत के साथ)

#pragma omp forवर्तमान टीम में विभिन्न थ्रेड्स के लिए केवल लूप के अंशों को दर्शाता है । एक टीम कार्यक्रम को निष्पादित करने वाले थ्रेड्स का समूह है। कार्यक्रम की शुरुआत में, टीम में केवल एक सदस्य होता है: मास्टर थ्रेड जो प्रोग्राम चलाता है।

थ्रेड्स की एक नई टीम बनाने के लिए, आपको समानांतर कीवर्ड निर्दिष्ट करने की आवश्यकता है। इसे आसपास के संदर्भ में निर्दिष्ट किया जा सकता है:

#pragma omp parallel
{
   #pragma omp for
   for(int n = 0; n < 10; ++n)
   printf(" %d", n);
}

तथा:

क्या हैं: समानांतर, एक टीम के लिए

और इसके लिए समानांतर, समानांतर के बीच का अंतर इस प्रकार है:

एक टीम थ्रेड्स का समूह है जो वर्तमान में निष्पादित होता है। कार्यक्रम की शुरुआत में, टीम में एक ही धागा होता है। एक समानांतर निर्माण वर्तमान धागे को अगले ब्लॉक / स्टेटमेंट की अवधि के लिए थ्रेड की एक नई टीम में विभाजित करता है, जिसके बाद टीम वापस एक में विलीन हो जाती है। के लिए वर्तमान टीम के धागे के बीच में लूप के काम को विभाजित करता है।

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

https://bisqwit.iki.fi/story/howto/openmp/