लूप

Question

के भीतर ओपनएमपी सिंक्रनाइज़ेशन मेरे पास एक बड़ा लूप है जो डेटा उत्पन्न करता है। प्रत्येक पुनरावृत्ति लेता है, कहता है, 1 सेकंड और डेटा का एक हिस्सा पैदा करता है। मुझे सही क्रम में फ़ाइल में लिखे गए सभी हिस्सों की आवश्यकता है।

अगर मैं सिर्फ पाश parallelize करना चाहता था, मैं इस (अत्यधिक सरल) की तरह कुछ लिख सकते हैं:

FILE* f = fopen("output.txt", "w"); 
    omp_lock_t lock; 
    omp_init_lock(&lock); 
    int nIterations = 1000000; 
#pragma omp parallel for 
    for(int thread=0; thread<4; thread++) 
    { 
     int a=0, b=0, c=0; 
     for(int n=thread; n<nIterations; n+=4) 
     { 
      int value = do_computations(&a, &b, &c); 
      omp_set_lock(&lock); 
      fprintf(f, "%d\n", value); 
      omp_unset_lock(&lock); 
     } 
    } 
#pragma omp barrier 
    fclose(f); 
    omp_destroy_lock(&lock); 

इस फ़ाइल में मेरी उत्पादन हो जाता है, लेकिन प्रविष्टियों में से आदेश की गारंटी नहीं दी जाएगी।

मैं निष्पादन को सिंक्रनाइज़ करना चाहता हूं ताकि सभी थ्रेड उनके कार्य कर सकें, फिर मास्टर थ्रेड फ़ाइल में लिखता है, और फिर धागे फिर से शुरू होते हैं। दूसरे शब्दों में, मैं कुछ इस तरह करना चाहते हैं:

#pragma omp parallel for 
     for(int thread=0; thread<4; thread++) 
     { 
      int a=0, b=0, c=0; 
      int values[4]; 
      for(int n=thread; n<nIterations; n+=4) 
      { 
       values[n] = do_computations(&a, &b, &c); 
#pragma omp barrier 
       if(thread == 0) 
       { 
         for(int i=0; i<4; i++) 
         fprintf(f, "%d\n", values[i]); 
       } 
#pragma omp barrier 
      } 
     } 
#pragma omp barrier 

छोड़कर, कुछ अबोध्य कारण के लिए, इस OpenMP विनिर्देश द्वारा निषिद्ध है।

या मैं

#pragma omp parallel for 
     for(int thread=0; thread<4; thread++) 
     { 
      int a=0, b=0, c=0; 
      for(int n=thread; n<nIterations; n+=4) 
      { 
       int value = do_computations(&a, &b, &c); 
#pragma omp ordered 
       { 
        fprintf(f, "%d\n", value); 
       } 
      } 
     } 
    #pragma omp barrier 
     fclose(f); 

की कोशिश कर सकते लेकिन वह, या तो काम नहीं करेगा क्योंकि "के साथ एक पाश की एक यात्रा एक निर्माण के लिए ... एक से अधिक आदेश दिया निर्देश पर अमल नहीं करना चाहिए।"

मैं कोड को एक लूप के रूप में फिर से लिखना नहीं चाहता हूं और मैं लूप का आदान-प्रदान नहीं करना चाहता हूं।

क्या अन्य थ्रेडिंग/सिंक्रनाइज़ेशन टूल के बिना ओपनएमपी के साथ ऐसा करने का कोई साफ तरीका है?

Answer 1

आप दो चीजें करने की कोशिश कर रहे हैं - एक गणना और आईओ। गणना समानांतर हो सकती है, लेकिन आईओ जरूरी है कि धारावाहिक हो। लेकिन आईओ को गणना के रूप में एक ही लूप में डालकर, आप गणना पर क्रमबद्धीकरण को भी मजबूर कर रहे हैं, जो कोई समझ नहीं आता है।

आप सभी गणना, फिर आईओ करने से बेहतर होगा। सीरियल में यह लगभग निश्चित रूप से तेज़ होगा, खासकर यदि आप fprintfs पर लूप के बजाय बाइनरी में डेटा को एक बड़े हिस्से में लिख सकते हैं।

FILE* f = fopen("output.txt", "w"); 
    const int nIterations = 1000000; 
    int values[nIterations]; 

#pragma omp parallel for 
    for(int n=0; n<niterations; n++) 
    { 
     int a=0, b=0, c=0; 
     values[n] = do_computations(&a, &b, &c); 
    } 

    for (int n=0; n<niterations; n++) 
     fprintf(f,"%d\n", values[n]); 

    fclose(f); 

इसके लिए अधिक स्मृति की आवश्यकता है, लेकिन फिर गति बनाम स्मृति एक आम व्यापार-बंद है। कि तालमेल के चरम काम नहीं करते हैं, तो आप हमेशा समायोज्य आकार मात्रा में गणना कर सकते हैं:

const int nIterations = 1000000; 
    const int chunkSize = 10000; 
    int values[chunkSize]; 
    int chunkNum = 0; 
    int chunkLeft = chunkSize; 

    for (int start = 0; start < nIterations; start+= chunkSize) { 

     if (start+chunkSize > nIterations) chunkLeft = nIterations - start; 

    #pragma omp parallel for 
     for(int n=start; n<start+chunkLeft; n++) 
     { 
      int a=0, b=0, c=0; 
      values[n-start] = do_computations(&a, &b, &c); 
     } 

     for (int n=0; n<chunkLeft; n++) 
      fprintf(f,"%d\n", values[n]); 

    } 
    fclose(f); 

Answer 2

मैं एक समाधान पहले से ही पूर्व उत्तर में मौजूद नहीं का प्रस्ताव करने की कोशिश करेंगे:

#include <stdio.h> 
#include <assert.h> 
#include <unistd.h> 

#define NITER 100 

int main() { 

    FILE * f = fopen("output.bin", "w+"); 

#pragma omp parallel 
    { 
#pragma omp for schedule(runtime) 
    for (int ii = 0; ii < NITER; ++ii) {  
     sleep(1); // Simulate computation 
     printf("%d\n",ii); // Just to be convinced that the loop is not evaluated in serial order 
#pragma omp critical (FILEWRITE) 
     { 
    fseek (f ,sizeof(ii)*ii,SEEK_SET); 
    fwrite(&ii,sizeof(ii),1,f); 
     }  
    } 
    } 

    // Check serially that the file is written in the right order 
    fseek(f,0,SEEK_SET); 
    int value = -1; 
    for (int ii = 0; ii < NITER; ++ii) {   
    fread (&value,sizeof(ii),1,f);  
    assert(value == ii); 
    } 

    fclose(f); 
    return 0; 
} 

यह मामला तभी लागू होता है जब प्रत्येक खंड में एक बहुत अच्छी तरह से परिभाषित आकार होता है ताकि यह पता चल सके कि आप किस कंप्यूटिंग को कंप्यूटिंग कर रहे हैं, तो आप फ़ाइल की शुरुआत से अपना ऑफसेट प्राप्त कर सकते हैं।

उस ने कहा, कोड स्निपेट में आप प्रदान कर रहे हैं कई त्रुटियां हैं जो सुझाव देती हैं कि आपको ओपनएमपी की मूलभूत समीक्षा की जानी चाहिए। उदाहरण के लिए:

#pragma omp parallel for 
    for(int thread=0; thread<4; thread++) 
    { // No need to unroll the loop as OpenMP runtime 
     // map iterations on threads based on the scheduling policy 
     int a=0, b=0, c=0; 
     for(int n=thread; n<nIterations; n+=4) 
     { 
      int value = do_computations(&a, &b, &c); 
      // No need to use lock, when a critical construct suffices 
      omp_set_lock(&lock); 
      fprintf(f, "%d\n", value); 
      omp_unset_lock(&lock); 
     } 
    } // Implicit barrier at the end of the parallel for 
#pragma omp barrier 
// Why a barrier when there is only one thread? 

Answer 3

पार्टी के लिए देर हो चुकी है, लेकिन अगर किसी को यहाँ जवाब की तलाश में ठोकर, तुम क्या जरूरत है #pragma omp single है, लेकिन साथ ही @ जोनाथन-dursi के साथ चर्चा देखें।