使用 OpenMP 并行化嵌套循环

Question

也许我的问题的解决方案对于一些有 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] 中的缩减计算仍然给出与例程的串行版本相同的值的最佳方法？如何以数字安全的方式进行循环融合？

Answer 1

我看到了几件事。

1) #pragma for ordered 表示：按顺序执行此循环的每一次迭代。这实质上意味着当您执行 "in parallel," 时，您的所有工作都将按顺序完成。删除它。

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)

使用 OpenMP 并行化嵌套循环

Parallelizing nested loops with OpenMP

c++

openmp