使用OpenMP并行嵌套循环

Parallelizing nested loops with OpenMP

本文关键字：嵌套循环 并行 OpenMP 使用      更新时间：2023-10-16

也许对一些有openmp经验的人来说，我的问题的解决方案是显而易见的，但我没有。我想使用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并行化之后，eris[ijkl]中的减少的计算，仍然给出与串行版本的例程相同的值的最佳方法？如何以数字安全的方式进行循环融合？

我看到了一些东西。

1） #pragma for ordered的意思是：按顺序执行该循环的每一次迭代。这本质上意味着，当你"并行"执行时，你的所有工作都将串行完成。移除它。

2） 您尚未声明任何变量为共享变量或私有变量。注意，默认情况下，所有变量都是共享的，因此在您的情况下，例如ij和kl将可由任何迭代中的任何线程访问。毫无疑问，如果迭代100改变了变量ij，而迭代1认为它在使用它，那么这将如何导致竞争条件。

3） 您正确指出的变量eris[ijkl]必须适当减少。如果在i_orbital循环中的两个不同迭代中，ijkl永远不可能是相同的值，那么就可以了；没有两个线程可能同时改变相同的变量CCD_ 8。如果它可以是相同的值，那么您必须小心地处理数组上的归约。

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)
相关文章：