0

プログラムでフラックス計算を高速化するためにオープン MP を使用しています。私は基本的に、OpenMP がこれらの左と右のフラックス計算の両方を並行して実行することを望んでいます。#pragmaしかし、逆に、次のコードはディレクティブでさらに時間がかかります。正しくするには何を変更すればよいですか？

#pragma omp parallel num_threads(2)
{

#pragma omp single
{//first condition
//cerr<<"Executed thread 0"<<endl;
        if ( (fabs(lcellMach-1.0)<EPSILON) || ( (lcellMach-1.0) > 0.0 ) ){//purpose of Epsilon!!!!
                FluxP[0] = rhol * vnl;
                FluxP[1] = rhol * ul * vnl + Pl*nx;
                FluxP[2] = rhol * vl * vnl + Pl*ny;
                FluxP[3] = rhol * wl * vnl + Pl*nz;
                FluxP[4] = rhol * ((GAMMA * Pl / (rhol * (GAMMA-1.0))) + ((ul*ul + vl*vl + wl*wl)/2.0)) * vnl;
        }else if ( (fabs(lcellMach+1.0)<EPSILON) || ( (lcellMach+1.0) < 0.0 ) ){
                FluxP[0] = FluxP[1] = FluxP[2] = FluxP[3] = FluxP[4] = 0.0;// If flow direction is opposite the Flux + is zero
        }else {
                double ql = (ul*ul + vl*vl + wl*wl);// how did this come
                FluxP[0] = rhol * lcell_a * (lcellMach+1.0)*(lcellMach+1.0) / 4.0;
                FluxP[1] = FluxP[0] * ( ul + (nx*(0.0-vnl + 2.0*lcell_a)/GAMMA) );
                FluxP[2] = FluxP[0] * ( vl + (ny*(0.0-vnl + 2.0*lcell_a)/GAMMA) );
                FluxP[3] = FluxP[0] * ( wl + (nz*(0.0-vnl + 2.0*lcell_a)/GAMMA) );
                FluxP[4] = FluxP[0] * (  ((ql - vnl*vnl)/2.0) + (((GAMMA-1.0)*vnl + 2.0*lcell_a)*((GAMMA-1.0)*vnl + 2.0*lcell_a) / (2.0*(GAMMA*GAMMA-1.0)))  );
        }
}//end of 1st
#pragma omp single
{//second condition
//cerr<<"Executed thread 1"<<endl;
        if ((fabs(rcellMach+1.0)<EPSILON) || ((rcellMach+1.0) < 0.0)) {
                FluxM[0] = rhor * vnr;
                FluxM[1] = rhor * ur * vnr + Pr*nx;
                FluxM[2] = rhor * vr * vnr + Pr*ny;
                FluxM[3] = rhor * wr * vnr + Pr*nz;
                FluxM[4] = rhor * ((GAMMA * Pr / (rhor * (GAMMA-1.0))) + ((ur*ur + vr*vr + wr*wr)/2.0)) * vnr;
        }else if ((fabs(rcellMach-1.0)<EPSILON) || ((rcellMach-1.0) > 0.0)) {
                FluxM[0] = FluxM[1] = FluxM[2] = FluxM[3] = FluxM[4] = 0.0;
        }else {
                tempFlux[0] = rhor * vnr;
                tempFlux[1] = rhor * ur * vnr + Pr*nx;
                tempFlux[2] = rhor * vr * vnr + Pr*ny;
                tempFlux[3] = rhor * wr * vnr + Pr*nz;
                tempFlux[4] = rhor * ((GAMMA * Pr / (rhor * (GAMMA-1.0))) + ((ur*ur + vr*vr + wr*wr)/2.0)) * vnr;

                double qr = (ur*ur + vr*vr + wr*wr);
                tempFluxP[0] = rhor * rcell_a * (rcellMach+1.0)*(rcellMach+1.0) / 4.0;
                tempFluxP[1] = tempFluxP[0] * ( ur + (nx*(0.0-vnr + 2.0*rcell_a)/GAMMA) );
                tempFluxP[2] = tempFluxP[0] * ( vr + (ny*(0.0-vnr + 2.0*rcell_a)/GAMMA) );
                tempFluxP[3] = tempFluxP[0] * ( wr + (nz*(0.0-vnr + 2.0*rcell_a)/GAMMA) );
                tempFluxP[4] = tempFluxP[0] * (  ((qr - vnr*vnr)/2.0) + (((GAMMA-1.0)*vnr + 2.0*rcell_a)*((GAMMA-1.0)*vnr + 2.0*rcell_a) / (2.0*(GAMMA*GAMMA-1.0)))  );

                for (int j=0; j<O; j++) FluxM[j] = tempFlux[j] - tempFluxP[j];
        }
}
}//pragma

緊急の助けが必要です。ありがとう。

4

1 に答える 1

1

必要なのはsections構造です：

#pragma omp parallel sections num_threads(2)
{
   #pragma omp section
   {
      ... code that updates FluxP ...
   }
   #pragma omp section
   {
      ... code that updates FluxM ...
   }
}

しかし、あなたのコードは計算を行うのにそれほど時間がかからないように見えます (forたとえば、内部に大きなループはありません)。そのため、OpenMP がコードにかけるオーバーヘッドは、計算時間の節約よりも多くの時間を消費する可能性が高く、したがって、並列バージョンは、おそらくシリアルよりも遅く実行されます。

于 2012-06-15T07:32:31.193 に答える