ओपनएमपी

Question

में साझा वैक्टर मैं एक प्रोग्राम को लंबित करने की कोशिश कर रहा हूं जिसका उपयोग मैं कर रहा हूं और निम्नलिखित प्रश्न प्राप्त कर रहा हूं। क्या मुझे एक ही वेक्टर पर कई धागे पढ़ने/लिखने की आवश्यकता है, लेकिन वेक्टर के विभिन्न तत्वों को पढ़ने के लिए मुझे प्रदर्शन का नुकसान मिलेगा? मुझे यह महसूस हो रहा है कि मेरे प्रोग्राम को इसे लंबित करने पर शायद ही कोई तेज़ हो जाता है। निम्नलिखित कोड डालें:

#include <vector> 

int main(){ 

    vector<double> numbers; 
    vector<double> results(10); 
    double x; 

    //write 10 values in vector numbers 
    for (int i =0; i<10; i++){ 
     numbers.push_back(cos(i)); 
    } 

#pragma omp parallel for \ 
    private(x) \ 
    shared(numbers, results) 
     for(int j = 0; j < 10; j++){ 

      x = 2 * numbers[j] + 5; 
#pragma omp critical // do I need this ? 
      { 
       results[j] = x;  
      } 
     } 

    return 0; 

} 

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

लेखन ऑपरेशन के साथ वही प्रश्न: क्या मुझे महत्वपूर्ण प्रगति की आवश्यकता है या क्या कोई समस्या नहीं है क्योंकि प्रत्येक थ्रेड वेक्टर परिणामों के एक अलग तत्व में लिखता है? मैं जो भी मदद प्राप्त कर सकता हूं उससे खुश हूं और यह जानना अच्छा होगा कि ऐसा करने का कोई बेहतर तरीका है (शायद वैक्टर का उपयोग न करें, लेकिन सरल सरणी और पॉइंटर्स इत्यादि?) मैंने वेक्टर भी पढ़े हैं कुछ मामलों में सुरक्षित धागा नहीं है और यह सूचक का उपयोग करने की अनुशंसा की जाती है: OpenMP and STL vector

आपकी मदद के लिए बहुत बहुत धन्यवाद!

Answer 1

मुझे कल्पना है कि कई धागे में वैक्टर के साथ अधिकांश मुद्दों का आकार बदलना होगा, फिर यह वेक्टर की पूरी सामग्री को स्मृति में एक नई जगह (एक बड़ा आवंटित हिस्सा) में कॉपी करता है, यदि आप हैं इसे समानांतर में एक्सेस करना, फिर आपने हटाए गए ऑब्जेक्ट को पढ़ने की कोशिश की।

आप अपने सरणी का आकार बदलना नहीं कर रहे हैं, तो मैं समवर्ती पढ़ने के साथ किसी भी मुसीबत नहीं था पड़ा है वेक्टर में लिखते हैं (जाहिर है, जब तक कि मैं दो बार एक ही तत्व नहीं लिख रहा हूँ)

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

आप महत्वपूर्ण अनुभाग कथन को हटा सकते हैं (शर्तों के साथ दिमाग में ऊपर)।

Answer 2

आपको महत्वपूर्ण सेक्टिनो की वजह से कोई गति नहीं मिलती है, जो कि अनावश्यक है, क्योंकि उसी तत्व को एक ही समय में कभी संशोधित नहीं किया जाएगा। महत्वपूर्ण खंड टुकड़ा निकालें और यह ठीक काम करेगा।

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

(BTW आप पाश अंदर x घोषित private(x) से बचने के लिए कर सकते हैं और shared निर्देश IIRC (मैं इसे इस्तेमाल कभी नहीं)। निहित है)