使用OpenMP并行化嵌套循环

Question

也许我的问题的解决方案对于openmp的exprience来说显而易见，但我没有。我想使用OpenMP加速下面的子例程：

void Build_ERIS(vector<double> &eris, vector<Atomic_Orbital> &Basis) 
{ 
    int basis_size = Basis.size(); 
    int m = basis_size*(basis_size+1)/2; 
    eris.resize(m*(m+1)/2); 
    bool compute; 
    std::fill(eris.begin(), eris.end(), 0); 

    int i_orbital,j_orbital, k_orbital,l_orbital, i_primitive, j_primitive, k_primitive,l_primitive,ij,kl, ijkl,ijij,klkl; 
    #pragma omp parallel 
    { 
    #pragma omp for ordered 
    for(i_orbital=0; i_orbital<basis_size; i_orbital++){ 
     for(j_orbital=0; j_orbital<i_orbital+1; j_orbital++){ 
    ij = i_orbital*(i_orbital+1)/2 + j_orbital; 
    for(k_orbital=0; k_orbital<basis_size; k_orbital++){ 
     for(l_orbital=0; l_orbital<k_orbital+1; l_orbital++){ 
     kl = k_orbital*(k_orbital+1)/2 + l_orbital; 
     if (ij >= kl) { 


      ijkl = composite_index(i_orbital,j_orbital,k_orbital,l_orbital); 

      ijij = composite_index(i_orbital,j_orbital,i_orbital,j_orbital); 
      klkl = composite_index(k_orbital,l_orbital,k_orbital,l_orbital); 

      for(i_primitive=0; i_primitive<Basis[i_orbital].contraction.size; i_primitive++) 
     for(j_primitive=0; j_primitive<Basis[j_orbital].contraction.size; j_primitive++) 
      for(k_primitive=0; k_primitive<Basis[k_orbital].contraction.size; k_primitive++) 
      for(l_primitive=0; l_primitive<Basis[l_orbital].contraction.size; l_primitive++) 
       eris[ijkl] += 
      normconst(Basis[i_orbital].contraction.exponent[i_primitive],Basis[i_orbital].angular.l, Basis[i_orbital].angular.m, Basis[i_orbital].angular.n)* 
      normconst(Basis[j_orbital].contraction.exponent[j_primitive],Basis[j_orbital].angular.l, Basis[j_orbital].angular.m, Basis[j_orbital].angular.n)* 
      normconst(Basis[k_orbital].contraction.exponent[k_primitive],Basis[k_orbital].angular.l, Basis[k_orbital].angular.m, Basis[k_orbital].angular.n)* 
      normconst(Basis[l_orbital].contraction.exponent[l_primitive],Basis[l_orbital].angular.l, Basis[l_orbital].angular.m, Basis[l_orbital].angular.n)* 
      Basis[i_orbital].contraction.coef[i_primitive]* 
      Basis[j_orbital].contraction.coef[j_primitive]* 
      Basis[k_orbital].contraction.coef[k_primitive]* 
      Basis[l_orbital].contraction.coef[l_primitive]* 
      ERI_int(Basis[i_orbital].contraction.center.x, Basis[i_orbital].contraction.center.y, Basis[i_orbital].contraction.center.z, Basis[i_orbital].contraction.exponent[i_primitive],Basis[i_orbital].angular.l, Basis[i_orbital].angular.m, Basis[i_orbital].angular.n, 
       Basis[j_orbital].contraction.center.x, Basis[j_orbital].contraction.center.y, Basis[j_orbital].contraction.center.z, Basis[j_orbital].contraction.exponent[j_primitive],Basis[j_orbital].angular.l, Basis[j_orbital].angular.m, Basis[j_orbital].angular.n, 
       Basis[k_orbital].contraction.center.x, Basis[k_orbital].contraction.center.y, Basis[k_orbital].contraction.center.z, Basis[k_orbital].contraction.exponent[k_primitive],Basis[k_orbital].angular.l, Basis[k_orbital].angular.m, Basis[k_orbital].angular.n, 
       Basis[l_orbital].contraction.center.x, Basis[l_orbital].contraction.center.y, Basis[l_orbital].contraction.center.z, Basis[l_orbital].contraction.exponent[l_primitive],Basis[l_orbital].angular.l, Basis[l_orbital].angular.m, Basis[l_orbital].angular.n); 

      /**/ 
     } 
     } 

    } 

     } 
    } 
    } 
} 

我关心的是关于肯定的是，OpenMP并行化后，在阋神星的减排量的计算[IJKL]，仍用相同的值的最佳方式例程的序列版本？我怎样才能以数字安全的方式进行循环融合？

Answer 1

我看到的几件事。

1）#pragma for ordered表示：按顺序执行该循环的每一次迭代。这基本上意味着，当你在“并行”执行时，你的所有工作都将以串行方式完成。去掉它。

2）您还没有声明任何变量是共享的还是私有的。请注意，默认情况下，所有变量都将被共享，因此您的案例ij和kl可以由任何迭代工作的任何线程访问。毫无疑问，如果迭代100改变了变量ij，而迭代1认为它正在使用它，那么这将会导致竞争状况。

3）您正确注意的变量eris[ijkl]必须正确减少。如果ijkl在i_orbital循环中永远不可能是两次不同迭代的相同值，那么您就像原样;没有两个线程可能会同时更改相同的变量eris[ijkl]。如果它可以是相同的值，那么你have to carefully handle reduction on the array。

4）下面是你应该为初学者工作。这假设ijkl将永远不会是两个不同迭代的相同值，并且您的函数不会接受任何非常量引用（可能会将输入变量假设为输出变量）。

#pragma omp parallel for private(i_orbital, j_orbital, ij, k_orbital, l_orbital, kl, ijkl, ijij, klkl, i_primitive, j_primitive, k_primitive, l_primitive)