ओपनएमपी कोड दिए गए निर्भरता ग्राफ

Question

मेरे पास ओपनएमपी छद्म कोड का उत्पादन करने के बारे में एक सवाल है जब आपके पास एक विशिष्ट निर्भरता ग्राफ दिमाग में है। तो लगता है कि हम इस विशिष्ट ग्राफ है:

एक समाधान कुछ इस तरह हो सकता है:

#pragma omp parallel 
    { 
     #pragma omp single 
     { 
      A(); 
      #pragma omp task B(); 
      #pragma omp task C(); 
      D(); 
      #pragma omp taskwait 
      #pragma omp task E(); 
      F(); 
     } 
    } 

अब बात यह है कि हालांकि कोड ऊपर महत्वपूर्ण समानांतरवाद सफल होने करता है, कार्य ई कार्य डी को पूरा करने के लिए इंतजार करना होगा और कार्य F को कार्य बी को पूरा करने की प्रतीक्षा करनी होगी, जिसे ग्राफ़ के अनुसार आवश्यक नहीं है।

तो मेरा सवाल यह है कि, क्या कोई मुझे ओपनएमपी छद्म कोड प्रदान कर सकता है जहां ई इंतजार नहीं करेगा डी और एफ दिए गए निर्भरता ग्राफ के लिए बी की प्रतीक्षा नहीं करेगा?

Answer 1

इस उद्देश्य के लिए, ओपनएमपी मानक task निर्देश के लिए depend खंड का प्रस्ताव करता है।

अपने विशिष्ट मामले में, मुझे लगता है कि यह इस तरह इस्तेमाल किया जा सकता:

#include <stdio.h> 

int a, b, c; 

void A() { 
    a = b = c = 1; 
    printf("[%d]In A: a=%d b=%d c=%d\n", omp_get_thread_num(), a, b, c); 
} 

void B() { 
    a++; 
    sleep(3); 
    printf("[%d]In B: a=%d\n", omp_get_thread_num(), a); 
} 

void C() { 
    b++; 
    sleep(2); 
    printf("[%d]In C: b=%d\n", omp_get_thread_num(), b); 
} 

void D() { 
    c++; 
    sleep(1); 
    printf("[%d]In D: c=%d\n", omp_get_thread_num(), c); 
} 

void E() { 
    a++; 
    sleep(3); 
    printf("[%d]In E: a=%d, b=%d\n", omp_get_thread_num(), a, b); 
} 

void F() { 
    c++; 
    sleep(1); 
    printf("[%d]In F: b=%d c=%d\n", omp_get_thread_num(), b, c); 
} 

int main() { 

    #pragma omp parallel num_threads(8) 
    { 
     #pragma omp single 
     { 
      #pragma omp task depend(out: a, b, c) 
      A(); 
      #pragma omp task depend(inout: a) 
      B(); 
      #pragma omp task depend(inout: b) 
      C(); 
      #pragma omp task depend(inout: c) 
      D(); 
      #pragma omp task depend(inout: a) depend(in: b) 
      E(); 
      #pragma omp task depend(inout: c) depend(in: b) 
      F(); 
     } 
    } 
    printf("Finally a=%d b=%d c=%d\n", a, b, c); 

    return 0; 
} 

आप देख सकते हैं, मैं कुछ चर a, b और c जो मैं कार्यों भर निर्भरता को परिभाषित करने के लिए उपयोग की शुरुआत की। मैं उन्हें तदनुसार कॉल में भी संशोधित करता हूं, हालांकि यह आवश्यक नहीं है (मैंने केवल यह दिखाने के लिए किया कि प्रवाह कैसे संभाला गया था)।

और यहाँ मैं अपने मशीन पर प्राप्त होता है:

~/tmp$ gcc -fopenmp depend.c 
~/tmp$ ./a.out 
[6]In A: a=1 b=1 c=1 
[7]In D: c=2 
[2]In C: b=2 
[6]In B: a=2 
[2]In F: b=2 c=3 
[6]In E: a=3, b=2 
Finally a=3 b=2 c=3