ループ内のOpenMP同期

Question

データを生成する大きなループがあります。各反復は、例えば1秒を要し、データの塊を生成する。私はすべてのチャンクが正しい順序でファイルに書き込まれる必要があります。私はループを並列化したい場合は

、私は（非常に簡略化）このような何かを書くことができ：これはファイルに私の出力を取得しますが、エントリの順序は保証されません

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); 

。

実行を同期して、すべてのスレッドが自分のタスクを実行してから、マスタスレッドがファイルに書き込みを行った後、スレッドを再開します。いくつかの不可解な理由のために、これは、OpenMP仕様で禁止されて、除き

#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 

：つまり、私はこのような何かをしたいと思います。

または私は

#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); 

を試みることができる。しかしそのためには、いずれかの動作しません「と、ループの反復が構築物について...つ以上の注文指示を実行してはいけません。」

コードを1つのループとして書き直したくないので、ループを交換したくありません。

他のスレッド/同期ツールを使用せずにOpenMPでこれを行うには、きれいな方法がありますか？

Answer 1

計算とIOという2つのことをしようとしています。計算は並列化することができますが、IOは必ずシリアルにする必要があります。しかし、IOを計算と同じループに置くことによって、計算にもシリアル化が強制されますが、これは意味をなさないのです。

すべての計算を行う方がはるかに良いでしょう。次に IOを実行します。 fprintfsのループではなくバイナリで1つの大きなチャンクでデータを書き出すことができれば、これはシリアルであってもほぼ確実に高速になります。

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; 
} 

を

このケースは、各チャンクが非常によく定義されたサイズを持つ場合にのみ適用されるため、計算の繰り返しを知っていれば、ファイルの先頭からオフセットを派生させることができます。

つまり、提供しているコードスニペットには、OpenMPの基本を確認する必要があることを示唆する多くのエラーがあります。例えば：誰かがここで答えを探してつまずく場合

は

#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 @との議論を参照してください。