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表示：按顺序执行此循环的每一次迭代。这实际上意味着当你并行执行＆＃34;＆＃34;你的所有工作都将按顺序完成。删除它。

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

3）正确指出的变量eris[ijkl]必须正确缩小。如果ijkl循环中i_orbital的两个不同迭代的eris[ijkl]永远不会是相同的值，那么您就可以了。没有两个线程可能会同时更改同一个变量ijkl。如果它可以是相同的值，那么您have to carefully handle reduction on the array。

4）这是你应该为初学者工作的。这假设#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)对于两个不同的迭代永远不会是相同的值，并且您的函数不会接受任何非常量引用（可能会改变我假设输入变量输出变量的内容）。 / p>

#include<stdio.h>

void printCard(char name, char symbol);

int main()
{
    printCard('J','*');
    printCard('K','&');  
}
void printCard(char name, char symbol)
{
    printf("-------------\n");
    printf("| %c         |\n",name);
    printf("| %c         |\n",symbol);
    printf("|           |\n");
    printf("|           |\n");
    printf("|           |\n");
    printf("|         %c |\n",symbol);
    printf("|         %c |\n",name);
    printf("-------------\n");
}

使用OpenMP并行化嵌套循环

1 个答案: