filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
Sitaras/Parallel-Systems-Project/HybridMPI/jacobi_hybrid.c | #pragma omp parallel for shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static) | 100 | )) - 2.0*(1.0-FY(y)*FY(y)))
int x, y;
double temp_error = 0.0;
double updateVal;
<LOOP-START>for(x=1;x<(size-1);x++){
int y=1;
updateVal = ( (SRC(x-1,y) + SRC(x+1,y))*cx + (SRC(x,y-1) + SRC(x,y+1))*cy + SRC(x,y)*cc - F(x,y))/cc;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
y=size-2;
updateVal = ( (SRC(x-1,y) + SRC(x+1,y))*cx + (SRC(x,y-1) + SRC(x,y+1))*cy + SRC(x,y)*cc - F(x,y))/cc;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static)<OMP-END> |
Sitaras/Parallel-Systems-Project/HybridMPI/jacobi_hybrid.c | #pragma omp parallel for shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static) | 100 | ;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
}
<LOOP-START>for(y=2;y<(size-2);y++){
int x=1;
updateVal = ( (SRC(x-1,y) + SRC(x+1,y))*cx + (SRC(x,y-1) + SRC(x,y+1))*cy + SRC(x,y)*cc - F(x,y))/cc;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
x=size-2;
updateVal = ( (SRC(x-1,y) + SRC(x+1,y))*cx + (SRC(x,y-1) + SRC(x,y+1))*cy + SRC(x,y)*cc - F(x,y))/cc;
DST(x,y) = SRC(x,y) - omega*updateVal;
temp_error += updateVal*updateVal;
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(size,src,dst,xStart,yStart,deltaX,deltaY,alpha,omega,cx,cy,cc),private(y,x,updateVal),reduction(+:temp_error) schedule(static)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for shared(nRows,nPaddedCols, other, data) | 100 | ; iter < iterHighBound; iter++ )
{
/* apply the stencil operator */
<LOOP-START>#pragma acc parallel loop collapse(2) independent present(data,other)
for( unsigned int i = 1; i < (nRows-1); i++ )
{
// #pragma omp parallel for
// #pragma acc loop independent
for( unsigned int j = 1; j < (nPaddedCols-1); j++ )
{
float oldCenterValue = dval(data, nPaddedCols, i, j);
float oldNSEWValues = dval(data, nPaddedCols, i - 1, j ) +
dval(data, nPaddedCols, i + 1, j ) +
dval(data, nPaddedCols, i, j - 1 ) +
dval(data, nPaddedCols, i, j + 1 );
float oldDiagonalValues = dval(data, nPaddedCols, i - 1, j - 1) +
dval(data, nPaddedCols, i - 1, j + 1) +
dval(data, nPaddedCols, i + 1, j - 1) +
dval(data, nPaddedCols, i + 1, j + 1);
float newVal = wCenter * oldCenterValue +
wCardinal * oldNSEWValues +
wDiagonal * oldDiagonalValues;
dval(other, nPaddedCols, i, j ) = newVal;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(nRows,nPaddedCols, other, data)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for | 100 | ta,other)
for( unsigned int i = 1; i < (nRows-1); i++ )
{
// <LOOP-START>// #pragma acc loop independent
for( unsigned int j = 1; j < (nPaddedCols-1); j++ )
{
float oldCenterValue = dval(data, nPaddedCols, i, j);
float oldNSEWValues = dval(data, nPaddedCols, i - 1, j ) +
dval(data, nPaddedCols, i + 1, j ) +
dval(data, nPaddedCols, i, j - 1 ) +
dval(data, nPaddedCols, i, j + 1 );
float oldDiagonalValues = dval(data, nPaddedCols, i - 1, j - 1) +
dval(data, nPaddedCols, i - 1, j + 1) +
dval(data, nPaddedCols, i + 1, j - 1) +
dval(data, nPaddedCols, i + 1, j + 1);
float newVal = wCenter * oldCenterValue +
wCardinal * oldNSEWValues +
wDiagonal * oldDiagonalValues;
dval(other, nPaddedCols, i, j ) = newVal;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for shared(nRows,nPaddedCols,other,data) | 100 | this successfully
* within OpenACC parallel region.
*/
// <LOOP-START>#pragma acc parallel loop collapse(2) independent present(data,other)
for( unsigned int i = 1; i < (nRows - 1); i++ )
{
//#pragma omp parallel for
//#pragma acc loop independent
for( unsigned int j = 1; j < (nCols - 1); j++ )
{
dval(data, nPaddedCols, i, j) = dval(other, nPaddedCols, i, j);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(nRows,nPaddedCols,other,data)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for | 100 | sent(data,other)
for( unsigned int i = 1; i < (nRows - 1); i++ )
{
//<LOOP-START>//#pragma acc loop independent
for( unsigned int j = 1; j < (nCols - 1); j++ )
{
dval(data, nPaddedCols, i, j) = dval(other, nPaddedCols, i, j);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for shared(nRows, nPaddedCols, other, data) | 100 | iter < iterHighBound; iter++ )
{
/* apply the stencil operator */
//<LOOP-START>#pragma acc parallel loop collapse(2) independent present(other,data)
for( unsigned int i = 1; i < (nRows-1); i++ )
{
for( unsigned int j = 1; j < (nPaddedCols-1); j++ )
{
double oldCenterValue = dval(data, nPaddedCols, i, j);
double oldNSEWValues = dval(data, nPaddedCols, i - 1, j ) +
dval(data, nPaddedCols, i + 1, j ) +
dval(data, nPaddedCols, i, j - 1 ) +
dval(data, nPaddedCols, i, j + 1 );
double oldDiagonalValues = dval(data, nPaddedCols, i - 1, j - 1) +
dval(data, nPaddedCols, i - 1, j + 1) +
dval(data, nPaddedCols, i + 1, j - 1) +
dval(data, nPaddedCols, i + 1, j + 1);
double newVal = wCenter * oldCenterValue +
wCardinal * oldNSEWValues +
wDiagonal * oldDiagonalValues;
dval(other, nPaddedCols, i, j ) = newVal;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(nRows, nPaddedCols, other, data)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for shared(nRows, nCols, nPaddedCols, other, data) | 100 | to do this successfully
* within OpenACC parallel region.
*/
<LOOP-START>#pragma acc parallel loop collapse(2) independent present(other,data)
for( unsigned int i = 1; i < (nRows - 1); i++ )
{
//#pragma omp parallel for
//#pragma acc loop independent
for( unsigned int j = 1; j < (nCols - 1); j++ )
{
dval(data, nPaddedCols, i, j) = dval(other, nPaddedCols, i, j);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(nRows, nCols, nPaddedCols, other, data)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/stencil2d/StencilFuncs.cpp | #pragma omp parallel for | 100 | sent(other,data)
for( unsigned int i = 1; i < (nRows - 1); i++ )
{
//<LOOP-START>//#pragma acc loop independent
for( unsigned int j = 1; j < (nCols - 1); j++ )
{
dval(data, nPaddedCols, i, j) = dval(other, nPaddedCols, i, j);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/md/MDFuncs.cpp | #pragma omp parallel for | 100 | o the accelerator
for( unsigned int iter = 0; iter < nIters; iter++ )
{
<LOOP-START>#pragma acc parallel loop independent
for (int i = 0; i < nAtom; i++)
{
float4 ipos = position[i];
float3 f = {0.0f, 0.0f, 0.0f};
#pragma acc loop
for (int j = 0; j < maxNeighbors; j++)
{
int jidx = neighborList[j*nAtom + i];
float4 jpos = position[jidx];
// Calculate distance
float delx = ipos.x - jpos.x;
float dely = ipos.y - jpos.y;
float delz = ipos.z - jpos.z;
float r2inv = delx*delx + dely*dely + delz*delz;
// If distance is less than cutoff, calculate force
if (r2inv < cutsq)
{
r2inv = 1.0f/r2inv;
float r6inv = r2inv * r2inv * r2inv;
float force = r2inv*r6inv*(lj1*r6inv - lj2);
f.x += delx * force;
f.y += dely * force;
f.z += delz * force;
}
} // for neighbors
force[i] = f;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/md/MDFuncs.cpp | #pragma omp parallel for | 100 | o the accelerator
for( unsigned int iter = 0; iter < nIters; iter++ )
{
<LOOP-START>#pragma acc parallel loop independent
for (int i = 0; i < nAtom; i++)
{
double4 ipos = position[i];
double3 f = {0.0f, 0.0f, 0.0f};
#pragma acc loop
for (int j = 0; j < maxNeighbors; j++)
{
int jidx = neighborList[j*nAtom + i];
double4 jpos = position[jidx];
// Calculate distance
double delx = ipos.x - jpos.x;
double dely = ipos.y - jpos.y;
double delz = ipos.z - jpos.z;
double r2inv = delx*delx + dely*dely + delz*delz;
// If distance is less than cutoff, calculate force
if (r2inv < cutsq)
{
r2inv = 1.0f/r2inv;
double r6inv = r2inv * r2inv * r2inv;
double force = r2inv*r6inv*(lj1*r6inv - lj2);
f.x += delx * force;
f.y += dely * force;
f.z += delz * force;
}
} // for neighbors
force[i] = f;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/reduction/ReduceFuncs.cpp | #pragma omp parallel for reduction(+:sum) default(none) shared(nItems,idata) | 100 | for( unsigned int iter = 0; iter < nIters; iter++ )
{
sum = 0.0;
<LOOP-START>//#pragma acc loop reduction( +:sum ) independent
#pragma acc kernels loop reduction( +:sum )
for( unsigned int i = 0; i < nItems; i++ )
{
sum += idata[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum) default(none) shared(nItems,idata)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/SHOC/openacc/level1/reduction/ReduceFuncs.cpp | #pragma omp parallel for reduction(+:sum) default(none) shared(nItems, idata) | 100 | for( unsigned int iter = 0; iter < nIters; iter++ )
{
sum = 0.0;
<LOOP-START>//#pragma acc loop reduction( +:sum ) independent
#pragma acc kernels loop reduction( +:sum )
for( unsigned int i = 0; i < nItems; i++ )
{
sum += idata[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum) default(none) shared(nItems, idata)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/BT/x_solve.c | #pragma omp parallel for default(shared) shared(isize) private(i,j,k,m,n) | 100 | eled f) and n jacobians
//---------------------------------------------------------------------
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (i = 0; i <= isize; i++) {
tmp1 = rho_i[k][j][i];
tmp2 = tmp1 * tmp1;
tmp3 = tmp1 * tmp2;
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
fjac[i][0][0] = 0.0;
fjac[i][1][0] = 1.0;
fjac[i][2][0] = 0.0;
fjac[i][3][0] = 0.0;
fjac[i][4][0] = 0.0;
fjac[i][0][1] = -(u[k][j][i][1] * tmp2 * u[k][j][i][1])
+ c2 * qs[k][j][i];
fjac[i][1][1] = ( 2.0 - c2 ) * ( u[k][j][i][1] / u[k][j][i][0] );
fjac[i][2][1] = - c2 * ( u[k][j][i][2] * tmp1 );
fjac[i][3][1] = - c2 * ( u[k][j][i][3] * tmp1 );
fjac[i][4][1] = c2;
fjac[i][0][2] = - ( u[k][j][i][1]*u[k][j][i][2] ) * tmp2;
fjac[i][1][2] = u[k][j][i][2] * tmp1;
fjac[i][2][2] = u[k][j][i][1] * tmp1;
fjac[i][3][2] = 0.0;
fjac[i][4][2] = 0.0;
fjac[i][0][3] = - ( u[k][j][i][1]*u[k][j][i][3] ) * tmp2;
fjac[i][1][3] = u[k][j][i][3] * tmp1;
fjac[i][2][3] = 0.0;
fjac[i][3][3] = u[k][j][i][1] * tmp1;
fjac[i][4][3] = 0.0;
fjac[i][0][4] = ( c2 * 2.0 * square[k][j][i] - c1 * u[k][j][i][4] )
* ( u[k][j][i][1] * tmp2 );
fjac[i][1][4] = c1 * u[k][j][i][4] * tmp1
- c2 * ( u[k][j][i][1]*u[k][j][i][1] * tmp2 + qs[k][j][i] );
fjac[i][2][4] = - c2 * ( u[k][j][i][2]*u[k][j][i][1] ) * tmp2;
fjac[i][3][4] = - c2 * ( u[k][j][i][3]*u[k][j][i][1] ) * tmp2;
fjac[i][4][4] = c1 * ( u[k][j][i][1] * tmp1 );
njac[i][0][0] = 0.0;
njac[i][1][0] = 0.0;
njac[i][2][0] = 0.0;
njac[i][3][0] = 0.0;
njac[i][4][0] = 0.0;
njac[i][0][1] = - con43 * c3c4 * tmp2 * u[k][j][i][1];
njac[i][1][1] = con43 * c3c4 * tmp1;
njac[i][2][1] = 0.0;
njac[i][3][1] = 0.0;
njac[i][4][1] = 0.0;
njac[i][0][2] = - c3c4 * tmp2 * u[k][j][i][2];
njac[i][1][2] = 0.0;
njac[i][2][2] = c3c4 * tmp1;
njac[i][3][2] = 0.0;
njac[i][4][2] = 0.0;
njac[i][0][3] = - c3c4 * tmp2 * u[k][j][i][3];
njac[i][1][3] = 0.0;
njac[i][2][3] = 0.0;
njac[i][3][3] = c3c4 * tmp1;
njac[i][4][3] = 0.0;
njac[i][0][4] = - ( con43 * c3c4
- c1345 ) * tmp3 * (u[k][j][i][1]*u[k][j][i][1])
- ( c3c4 - c1345 ) * tmp3 * (u[k][j][i][2]*u[k][j][i][2])
- ( c3c4 - c1345 ) * tmp3 * (u[k][j][i][3]*u[k][j][i][3])
- c1345 * tmp2 * u[k][j][i][4];
njac[i][1][4] = ( con43 * c3c4
- c1345 ) * tmp2 * u[k][j][i][1];
njac[i][2][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][2];
njac[i][3][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][3];
njac[i][4][4] = ( c1345 ) * tmp1;
}
//---------------------------------------------------------------------
// now jacobians set, so form left hand side in x direction
//---------------------------------------------------------------------
lhsinit(lhs, isize);
for (i = 1; i <= isize-1; i++) {
tmp1 = dt * tx1;
tmp2 = dt * tx2;
lhs[i][AA][0][0] = - tmp2 * fjac[i-1][0][0]
- tmp1 * njac[i-1][0][0]
- tmp1 * dx1;
lhs[i][AA][1][0] = - tmp2 * fjac[i-1][1][0]
- tmp1 * njac[i-1][1][0];
lhs[i][AA][2][0] = - tmp2 * fjac[i-1][2][0]
- tmp1 * njac[i-1][2][0];
lhs[i][AA][3][0] = - tmp2 * fjac[i-1][3][0]
- tmp1 * njac[i-1][3][0];
lhs[i][AA][4][0] = - tmp2 * fjac[i-1][4][0]
- tmp1 * njac[i-1][4][0];
lhs[i][AA][0][1] = - tmp2 * fjac[i-1][0][1]
- tmp1 * njac[i-1][0][1];
lhs[i][AA][1][1] = - tmp2 * fjac[i-1][1][1]
- tmp1 * njac[i-1][1][1]
- tmp1 * dx2;
lhs[i][AA][2][1] = - tmp2 * fjac[i-1][2][1]
- tmp1 * njac[i-1][2][1];
lhs[i][AA][3][1] = - tmp2 * fjac[i-1][3][1]
- tmp1 * njac[i-1][3][1];
lhs[i][AA][4][1] = - tmp2 * fjac[i-1][4][1]
- tmp1 * njac[i-1][4][1];
lhs[i][AA][0][2] = - tmp2 * fjac[i-1][0][2]
- tmp1 * njac[i-1][0][2];
lhs[i][AA][1][2] = - tmp2 * fjac[i-1][1][2]
- tmp1 * njac[i-1][1][2];
lhs[i][AA][2][2] = - tmp2 * fjac[i-1][2][2]
- tmp1 * njac[i-1][2][2]
- tmp1 * dx3;
lhs[i][AA][3][2] = - tmp2 * fjac[i-1][3][2]
- tmp1 * njac[i-1][3][2];
lhs[i][AA][4][2] = - tmp2 * fjac[i-1][4][2]
- tmp1 * njac[i-1][4][2];
lhs[i][AA][0][3] = - tmp2 * fjac[i-1][0][3]
- tmp1 * njac[i-1][0][3];
lhs[i][AA][1][3] = - tmp2 * fjac[i-1][1][3]
- tmp1 * njac[i-1][1][3];
lhs[i][AA][2][3] = - tmp2 * fjac[i-1][2][3]
- tmp1 * njac[i-1][2][3];
lhs[i][AA][3][3] = - tmp2 * fjac[i-1][3][3]
- tmp1 * njac[i-1][3][3]
- tmp1 * dx4;
lhs[i][AA][4][3] = - tmp2 * fjac[i-1][4][3]
- tmp1 * njac[i-1][4][3];
lhs[i][AA][0][4] = - tmp2 * fjac[i-1][0][4]
- tmp1 * njac[i-1][0][4];
lhs[i][AA][1][4] = - tmp2 * fjac[i-1][1][4]
- tmp1 * njac[i-1][1][4];
lhs[i][AA][2][4] = - tmp2 * fjac[i-1][2][4]
- tmp1 * njac[i-1][2][4];
lhs[i][AA][3][4] = - tmp2 * fjac[i-1][3][4]
- tmp1 * njac[i-1][3][4];
lhs[i][AA][4][4] = - tmp2 * fjac[i-1][4][4]
- tmp1 * njac[i-1][4][4]
- tmp1 * dx5;
lhs[i][BB][0][0] = 1.0
+ tmp1 * 2.0 * njac[i][0][0]
+ tmp1 * 2.0 * dx1;
lhs[i][BB][1][0] = tmp1 * 2.0 * njac[i][1][0];
lhs[i][BB][2][0] = tmp1 * 2.0 * njac[i][2][0];
lhs[i][BB][3][0] = tmp1 * 2.0 * njac[i][3][0];
lhs[i][BB][4][0] = tmp1 * 2.0 * njac[i][4][0];
lhs[i][BB][0][1] = tmp1 * 2.0 * njac[i][0][1];
lhs[i][BB][1][1] = 1.0
+ tmp1 * 2.0 * njac[i][1][1]
+ tmp1 * 2.0 * dx2;
lhs[i][BB][2][1] = tmp1 * 2.0 * njac[i][2][1];
lhs[i][BB][3][1] = tmp1 * 2.0 * njac[i][3][1];
lhs[i][BB][4][1] = tmp1 * 2.0 * njac[i][4][1];
lhs[i][BB][0][2] = tmp1 * 2.0 * njac[i][0][2];
lhs[i][BB][1][2] = tmp1 * 2.0 * njac[i][1][2];
lhs[i][BB][2][2] = 1.0
+ tmp1 * 2.0 * njac[i][2][2]
+ tmp1 * 2.0 * dx3;
lhs[i][BB][3][2] = tmp1 * 2.0 * njac[i][3][2];
lhs[i][BB][4][2] = tmp1 * 2.0 * njac[i][4][2];
lhs[i][BB][0][3] = tmp1 * 2.0 * njac[i][0][3];
lhs[i][BB][1][3] = tmp1 * 2.0 * njac[i][1][3];
lhs[i][BB][2][3] = tmp1 * 2.0 * njac[i][2][3];
lhs[i][BB][3][3] = 1.0
+ tmp1 * 2.0 * njac[i][3][3]
+ tmp1 * 2.0 * dx4;
lhs[i][BB][4][3] = tmp1 * 2.0 * njac[i][4][3];
lhs[i][BB][0][4] = tmp1 * 2.0 * njac[i][0][4];
lhs[i][BB][1][4] = tmp1 * 2.0 * njac[i][1][4];
lhs[i][BB][2][4] = tmp1 * 2.0 * njac[i][2][4];
lhs[i][BB][3][4] = tmp1 * 2.0 * njac[i][3][4];
lhs[i][BB][4][4] = 1.0
+ tmp1 * 2.0 * njac[i][4][4]
+ tmp1 * 2.0 * dx5;
lhs[i][CC][0][0] = tmp2 * fjac[i+1][0][0]
- tmp1 * njac[i+1][0][0]
- tmp1 * dx1;
lhs[i][CC][1][0] = tmp2 * fjac[i+1][1][0]
- tmp1 * njac[i+1][1][0];
lhs[i][CC][2][0] = tmp2 * fjac[i+1][2][0]
- tmp1 * njac[i+1][2][0];
lhs[i][CC][3][0] = tmp2 * fjac[i+1][3][0]
- tmp1 * njac[i+1][3][0];
lhs[i][CC][4][0] = tmp2 * fjac[i+1][4][0]
- tmp1 * njac[i+1][4][0];
lhs[i][CC][0][1] = tmp2 * fjac[i+1][0][1]
- tmp1 * njac[i+1][0][1];
lhs[i][CC][1][1] = tmp2 * fjac[i+1][1][1]
- tmp1 * njac[i+1][1][1]
- tmp1 * dx2;
lhs[i][CC][2][1] = tmp2 * fjac[i+1][2][1]
- tmp1 * njac[i+1][2][1];
lhs[i][CC][3][1] = tmp2 * fjac[i+1][3][1]
- tmp1 * njac[i+1][3][1];
lhs[i][CC][4][1] = tmp2 * fjac[i+1][4][1]
- tmp1 * njac[i+1][4][1];
lhs[i][CC][0][2] = tmp2 * fjac[i+1][0][2]
- tmp1 * njac[i+1][0][2];
lhs[i][CC][1][2] = tmp2 * fjac[i+1][1][2]
- tmp1 * njac[i+1][1][2];
lhs[i][CC][2][2] = tmp2 * fjac[i+1][2][2]
- tmp1 * njac[i+1][2][2]
- tmp1 * dx3;
lhs[i][CC][3][2] = tmp2 * fjac[i+1][3][2]
- tmp1 * njac[i+1][3][2];
lhs[i][CC][4][2] = tmp2 * fjac[i+1][4][2]
- tmp1 * njac[i+1][4][2];
lhs[i][CC][0][3] = tmp2 * fjac[i+1][0][3]
- tmp1 * njac[i+1][0][3];
lhs[i][CC][1][3] = tmp2 * fjac[i+1][1][3]
- tmp1 * njac[i+1][1][3];
lhs[i][CC][2][3] = tmp2 * fjac[i+1][2][3]
- tmp1 * njac[i+1][2][3];
lhs[i][CC][3][3] = tmp2 * fjac[i+1][3][3]
- tmp1 * njac[i+1][3][3]
- tmp1 * dx4;
lhs[i][CC][4][3] = tmp2 * fjac[i+1][4][3]
- tmp1 * njac[i+1][4][3];
lhs[i][CC][0][4] = tmp2 * fjac[i+1][0][4]
- tmp1 * njac[i+1][0][4];
lhs[i][CC][1][4] = tmp2 * fjac[i+1][1][4]
- tmp1 * njac[i+1][1][4];
lhs[i][CC][2][4] = tmp2 * fjac[i+1][2][4]
- tmp1 * njac[i+1][2][4];
lhs[i][CC][3][4] = tmp2 * fjac[i+1][3][4]
- tmp1 * njac[i+1][3][4];
lhs[i][CC][4][4] = tmp2 * fjac[i+1][4][4]
- tmp1 * njac[i+1][4][4]
- tmp1 * dx5;
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// performs guaussian elimination on this cell.
//
// assumes that unpacking routines for non-first cells
// preload C' and rhs' from previous cell.
//
// assumed send happens outside this routine, but that
// c'(IMAX) and rhs'(IMAX) will be sent to next cell
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// outer most do loops - sweeping in i direction
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// multiply c[k][j][0] by b_inverse and copy back to c
// multiply rhs(0) by b_inverse(0) and copy to rhs
//---------------------------------------------------------------------
binvcrhs( lhs[0][BB], lhs[0][CC], rhs[k][j][0] );
//---------------------------------------------------------------------
// begin inner most do loop
// do all the elements of the cell unless last
//---------------------------------------------------------------------
for (i = 1; i <= isize-1; i++) {
//-------------------------------------------------------------------
// rhs(i) = rhs(i) - A*rhs(i-1)
//-------------------------------------------------------------------
matvec_sub(lhs[i][AA], rhs[k][j][i-1], rhs[k][j][i]);
//-------------------------------------------------------------------
// B(i) = B(i) - C(i-1)*A(i)
//-------------------------------------------------------------------
matmul_sub(lhs[i][AA], lhs[i-1][CC], lhs[i][BB]);
//-------------------------------------------------------------------
// multiply c[k][j][i] by b_inverse and copy back to c
// multiply rhs[k][j][0] by b_inverse[k][j][0] and copy to rhs
//-------------------------------------------------------------------
binvcrhs( lhs[i][BB], lhs[i][CC], rhs[k][j][i] );
}
//---------------------------------------------------------------------
// rhs(isize) = rhs(isize) - A*rhs(isize-1)
//---------------------------------------------------------------------
matvec_sub(lhs[isize][AA], rhs[k][j][isize-1], rhs[k][j][isize]);
//---------------------------------------------------------------------
// B(isize) = B(isize) - C(isize-1)*A(isize)
//---------------------------------------------------------------------
matmul_sub(lhs[isize][AA], lhs[isize-1][CC], lhs[isize][BB]);
//---------------------------------------------------------------------
// multiply rhs() by b_inverse() and copy to rhs
//---------------------------------------------------------------------
binvrhs( lhs[isize][BB], rhs[k][j][isize] );
//---------------------------------------------------------------------
// back solve: if last cell, then generate U(isize)=rhs(isize)
// else assume U(isize) is loaded in un pack backsub_info
// so just use it
// after u(istart) will be sent to next cell
//---------------------------------------------------------------------
for (i = isize-1; i >=0; i--) {
for (m = 0; m < BLOCK_SIZE; m++) {
for (n = 0; n < BLOCK_SIZE; n++) {
rhs[k][j][i][m] = rhs[k][j][i][m]
- lhs[i][CC][n][m]*rhs[k][j][i+1][n];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) shared(isize) private(i,j,k,m,n)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/BT/add.c | #pragma omp parallel for default(shared) private(i,j,k,m) | 100 | ------------------------------
void add()
{
int i, j, k, m;
if (timeron) timer_start(t_add);
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (i = 1; i <= grid_points[0]-2; i++) {
for (m = 0; m < 5; m++) {
u[k][j][i][m] = u[k][j][i][m] + rhs[k][j][i][m];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,m)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/BT/z_solve.c | #pragma omp parallel for default(shared) shared(ksize) private(i,j,k,m,n) | 100 | eled f) and s jacobians
//---------------------------------------------------------------------
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 0; k <= ksize; k++) {
tmp1 = 1.0 / u[k][j][i][0];
tmp2 = tmp1 * tmp1;
tmp3 = tmp1 * tmp2;
fjac[k][0][0] = 0.0;
fjac[k][1][0] = 0.0;
fjac[k][2][0] = 0.0;
fjac[k][3][0] = 1.0;
fjac[k][4][0] = 0.0;
fjac[k][0][1] = - ( u[k][j][i][1]*u[k][j][i][3] ) * tmp2;
fjac[k][1][1] = u[k][j][i][3] * tmp1;
fjac[k][2][1] = 0.0;
fjac[k][3][1] = u[k][j][i][1] * tmp1;
fjac[k][4][1] = 0.0;
fjac[k][0][2] = - ( u[k][j][i][2]*u[k][j][i][3] ) * tmp2;
fjac[k][1][2] = 0.0;
fjac[k][2][2] = u[k][j][i][3] * tmp1;
fjac[k][3][2] = u[k][j][i][2] * tmp1;
fjac[k][4][2] = 0.0;
fjac[k][0][3] = - (u[k][j][i][3]*u[k][j][i][3] * tmp2 )
+ c2 * qs[k][j][i];
fjac[k][1][3] = - c2 * u[k][j][i][1] * tmp1;
fjac[k][2][3] = - c2 * u[k][j][i][2] * tmp1;
fjac[k][3][3] = ( 2.0 - c2 ) * u[k][j][i][3] * tmp1;
fjac[k][4][3] = c2;
fjac[k][0][4] = ( c2 * 2.0 * square[k][j][i] - c1 * u[k][j][i][4] )
* u[k][j][i][3] * tmp2;
fjac[k][1][4] = - c2 * ( u[k][j][i][1]*u[k][j][i][3] ) * tmp2;
fjac[k][2][4] = - c2 * ( u[k][j][i][2]*u[k][j][i][3] ) * tmp2;
fjac[k][3][4] = c1 * ( u[k][j][i][4] * tmp1 )
- c2 * ( qs[k][j][i] + u[k][j][i][3]*u[k][j][i][3] * tmp2 );
fjac[k][4][4] = c1 * u[k][j][i][3] * tmp1;
njac[k][0][0] = 0.0;
njac[k][1][0] = 0.0;
njac[k][2][0] = 0.0;
njac[k][3][0] = 0.0;
njac[k][4][0] = 0.0;
njac[k][0][1] = - c3c4 * tmp2 * u[k][j][i][1];
njac[k][1][1] = c3c4 * tmp1;
njac[k][2][1] = 0.0;
njac[k][3][1] = 0.0;
njac[k][4][1] = 0.0;
njac[k][0][2] = - c3c4 * tmp2 * u[k][j][i][2];
njac[k][1][2] = 0.0;
njac[k][2][2] = c3c4 * tmp1;
njac[k][3][2] = 0.0;
njac[k][4][2] = 0.0;
njac[k][0][3] = - con43 * c3c4 * tmp2 * u[k][j][i][3];
njac[k][1][3] = 0.0;
njac[k][2][3] = 0.0;
njac[k][3][3] = con43 * c3 * c4 * tmp1;
njac[k][4][3] = 0.0;
njac[k][0][4] = - ( c3c4
- c1345 ) * tmp3 * (u[k][j][i][1]*u[k][j][i][1])
- ( c3c4 - c1345 ) * tmp3 * (u[k][j][i][2]*u[k][j][i][2])
- ( con43 * c3c4
- c1345 ) * tmp3 * (u[k][j][i][3]*u[k][j][i][3])
- c1345 * tmp2 * u[k][j][i][4];
njac[k][1][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][1];
njac[k][2][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][2];
njac[k][3][4] = ( con43 * c3c4
- c1345 ) * tmp2 * u[k][j][i][3];
njac[k][4][4] = ( c1345 )* tmp1;
}
//---------------------------------------------------------------------
// now jacobians set, so form left hand side in z direction
//---------------------------------------------------------------------
lhsinit(lhs, ksize);
for (k = 1; k <= ksize-1; k++) {
tmp1 = dt * tz1;
tmp2 = dt * tz2;
lhs[k][AA][0][0] = - tmp2 * fjac[k-1][0][0]
- tmp1 * njac[k-1][0][0]
- tmp1 * dz1;
lhs[k][AA][1][0] = - tmp2 * fjac[k-1][1][0]
- tmp1 * njac[k-1][1][0];
lhs[k][AA][2][0] = - tmp2 * fjac[k-1][2][0]
- tmp1 * njac[k-1][2][0];
lhs[k][AA][3][0] = - tmp2 * fjac[k-1][3][0]
- tmp1 * njac[k-1][3][0];
lhs[k][AA][4][0] = - tmp2 * fjac[k-1][4][0]
- tmp1 * njac[k-1][4][0];
lhs[k][AA][0][1] = - tmp2 * fjac[k-1][0][1]
- tmp1 * njac[k-1][0][1];
lhs[k][AA][1][1] = - tmp2 * fjac[k-1][1][1]
- tmp1 * njac[k-1][1][1]
- tmp1 * dz2;
lhs[k][AA][2][1] = - tmp2 * fjac[k-1][2][1]
- tmp1 * njac[k-1][2][1];
lhs[k][AA][3][1] = - tmp2 * fjac[k-1][3][1]
- tmp1 * njac[k-1][3][1];
lhs[k][AA][4][1] = - tmp2 * fjac[k-1][4][1]
- tmp1 * njac[k-1][4][1];
lhs[k][AA][0][2] = - tmp2 * fjac[k-1][0][2]
- tmp1 * njac[k-1][0][2];
lhs[k][AA][1][2] = - tmp2 * fjac[k-1][1][2]
- tmp1 * njac[k-1][1][2];
lhs[k][AA][2][2] = - tmp2 * fjac[k-1][2][2]
- tmp1 * njac[k-1][2][2]
- tmp1 * dz3;
lhs[k][AA][3][2] = - tmp2 * fjac[k-1][3][2]
- tmp1 * njac[k-1][3][2];
lhs[k][AA][4][2] = - tmp2 * fjac[k-1][4][2]
- tmp1 * njac[k-1][4][2];
lhs[k][AA][0][3] = - tmp2 * fjac[k-1][0][3]
- tmp1 * njac[k-1][0][3];
lhs[k][AA][1][3] = - tmp2 * fjac[k-1][1][3]
- tmp1 * njac[k-1][1][3];
lhs[k][AA][2][3] = - tmp2 * fjac[k-1][2][3]
- tmp1 * njac[k-1][2][3];
lhs[k][AA][3][3] = - tmp2 * fjac[k-1][3][3]
- tmp1 * njac[k-1][3][3]
- tmp1 * dz4;
lhs[k][AA][4][3] = - tmp2 * fjac[k-1][4][3]
- tmp1 * njac[k-1][4][3];
lhs[k][AA][0][4] = - tmp2 * fjac[k-1][0][4]
- tmp1 * njac[k-1][0][4];
lhs[k][AA][1][4] = - tmp2 * fjac[k-1][1][4]
- tmp1 * njac[k-1][1][4];
lhs[k][AA][2][4] = - tmp2 * fjac[k-1][2][4]
- tmp1 * njac[k-1][2][4];
lhs[k][AA][3][4] = - tmp2 * fjac[k-1][3][4]
- tmp1 * njac[k-1][3][4];
lhs[k][AA][4][4] = - tmp2 * fjac[k-1][4][4]
- tmp1 * njac[k-1][4][4]
- tmp1 * dz5;
lhs[k][BB][0][0] = 1.0
+ tmp1 * 2.0 * njac[k][0][0]
+ tmp1 * 2.0 * dz1;
lhs[k][BB][1][0] = tmp1 * 2.0 * njac[k][1][0];
lhs[k][BB][2][0] = tmp1 * 2.0 * njac[k][2][0];
lhs[k][BB][3][0] = tmp1 * 2.0 * njac[k][3][0];
lhs[k][BB][4][0] = tmp1 * 2.0 * njac[k][4][0];
lhs[k][BB][0][1] = tmp1 * 2.0 * njac[k][0][1];
lhs[k][BB][1][1] = 1.0
+ tmp1 * 2.0 * njac[k][1][1]
+ tmp1 * 2.0 * dz2;
lhs[k][BB][2][1] = tmp1 * 2.0 * njac[k][2][1];
lhs[k][BB][3][1] = tmp1 * 2.0 * njac[k][3][1];
lhs[k][BB][4][1] = tmp1 * 2.0 * njac[k][4][1];
lhs[k][BB][0][2] = tmp1 * 2.0 * njac[k][0][2];
lhs[k][BB][1][2] = tmp1 * 2.0 * njac[k][1][2];
lhs[k][BB][2][2] = 1.0
+ tmp1 * 2.0 * njac[k][2][2]
+ tmp1 * 2.0 * dz3;
lhs[k][BB][3][2] = tmp1 * 2.0 * njac[k][3][2];
lhs[k][BB][4][2] = tmp1 * 2.0 * njac[k][4][2];
lhs[k][BB][0][3] = tmp1 * 2.0 * njac[k][0][3];
lhs[k][BB][1][3] = tmp1 * 2.0 * njac[k][1][3];
lhs[k][BB][2][3] = tmp1 * 2.0 * njac[k][2][3];
lhs[k][BB][3][3] = 1.0
+ tmp1 * 2.0 * njac[k][3][3]
+ tmp1 * 2.0 * dz4;
lhs[k][BB][4][3] = tmp1 * 2.0 * njac[k][4][3];
lhs[k][BB][0][4] = tmp1 * 2.0 * njac[k][0][4];
lhs[k][BB][1][4] = tmp1 * 2.0 * njac[k][1][4];
lhs[k][BB][2][4] = tmp1 * 2.0 * njac[k][2][4];
lhs[k][BB][3][4] = tmp1 * 2.0 * njac[k][3][4];
lhs[k][BB][4][4] = 1.0
+ tmp1 * 2.0 * njac[k][4][4]
+ tmp1 * 2.0 * dz5;
lhs[k][CC][0][0] = tmp2 * fjac[k+1][0][0]
- tmp1 * njac[k+1][0][0]
- tmp1 * dz1;
lhs[k][CC][1][0] = tmp2 * fjac[k+1][1][0]
- tmp1 * njac[k+1][1][0];
lhs[k][CC][2][0] = tmp2 * fjac[k+1][2][0]
- tmp1 * njac[k+1][2][0];
lhs[k][CC][3][0] = tmp2 * fjac[k+1][3][0]
- tmp1 * njac[k+1][3][0];
lhs[k][CC][4][0] = tmp2 * fjac[k+1][4][0]
- tmp1 * njac[k+1][4][0];
lhs[k][CC][0][1] = tmp2 * fjac[k+1][0][1]
- tmp1 * njac[k+1][0][1];
lhs[k][CC][1][1] = tmp2 * fjac[k+1][1][1]
- tmp1 * njac[k+1][1][1]
- tmp1 * dz2;
lhs[k][CC][2][1] = tmp2 * fjac[k+1][2][1]
- tmp1 * njac[k+1][2][1];
lhs[k][CC][3][1] = tmp2 * fjac[k+1][3][1]
- tmp1 * njac[k+1][3][1];
lhs[k][CC][4][1] = tmp2 * fjac[k+1][4][1]
- tmp1 * njac[k+1][4][1];
lhs[k][CC][0][2] = tmp2 * fjac[k+1][0][2]
- tmp1 * njac[k+1][0][2];
lhs[k][CC][1][2] = tmp2 * fjac[k+1][1][2]
- tmp1 * njac[k+1][1][2];
lhs[k][CC][2][2] = tmp2 * fjac[k+1][2][2]
- tmp1 * njac[k+1][2][2]
- tmp1 * dz3;
lhs[k][CC][3][2] = tmp2 * fjac[k+1][3][2]
- tmp1 * njac[k+1][3][2];
lhs[k][CC][4][2] = tmp2 * fjac[k+1][4][2]
- tmp1 * njac[k+1][4][2];
lhs[k][CC][0][3] = tmp2 * fjac[k+1][0][3]
- tmp1 * njac[k+1][0][3];
lhs[k][CC][1][3] = tmp2 * fjac[k+1][1][3]
- tmp1 * njac[k+1][1][3];
lhs[k][CC][2][3] = tmp2 * fjac[k+1][2][3]
- tmp1 * njac[k+1][2][3];
lhs[k][CC][3][3] = tmp2 * fjac[k+1][3][3]
- tmp1 * njac[k+1][3][3]
- tmp1 * dz4;
lhs[k][CC][4][3] = tmp2 * fjac[k+1][4][3]
- tmp1 * njac[k+1][4][3];
lhs[k][CC][0][4] = tmp2 * fjac[k+1][0][4]
- tmp1 * njac[k+1][0][4];
lhs[k][CC][1][4] = tmp2 * fjac[k+1][1][4]
- tmp1 * njac[k+1][1][4];
lhs[k][CC][2][4] = tmp2 * fjac[k+1][2][4]
- tmp1 * njac[k+1][2][4];
lhs[k][CC][3][4] = tmp2 * fjac[k+1][3][4]
- tmp1 * njac[k+1][3][4];
lhs[k][CC][4][4] = tmp2 * fjac[k+1][4][4]
- tmp1 * njac[k+1][4][4]
- tmp1 * dz5;
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// performs guaussian elimination on this cell.
//
// assumes that unpacking routines for non-first cells
// preload C' and rhs' from previous cell.
//
// assumed send happens outside this routine, but that
// c'(KMAX) and rhs'(KMAX) will be sent to next cell.
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// outer most do loops - sweeping in i direction
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// multiply c[0][j][i] by b_inverse and copy back to c
// multiply rhs(0) by b_inverse(0) and copy to rhs
//---------------------------------------------------------------------
binvcrhs( lhs[0][BB], lhs[0][CC], rhs[0][j][i] );
//---------------------------------------------------------------------
// begin inner most do loop
// do all the elements of the cell unless last
//---------------------------------------------------------------------
for (k = 1; k <= ksize-1; k++) {
//-------------------------------------------------------------------
// subtract A*lhs_vector(k-1) from lhs_vector(k)
//
// rhs(k) = rhs(k) - A*rhs(k-1)
//-------------------------------------------------------------------
matvec_sub(lhs[k][AA], rhs[k-1][j][i], rhs[k][j][i]);
//-------------------------------------------------------------------
// B(k) = B(k) - C(k-1)*A(k)
// matmul_sub(AA,i,j,k,c,CC,i,j,k-1,c,BB,i,j,k)
//-------------------------------------------------------------------
matmul_sub(lhs[k][AA], lhs[k-1][CC], lhs[k][BB]);
//-------------------------------------------------------------------
// multiply c[k][j][i] by b_inverse and copy back to c
// multiply rhs[0][j][i] by b_inverse[0][j][i] and copy to rhs
//-------------------------------------------------------------------
binvcrhs( lhs[k][BB], lhs[k][CC], rhs[k][j][i] );
}
//---------------------------------------------------------------------
// Now finish up special cases for last cell
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// rhs(ksize) = rhs(ksize) - A*rhs(ksize-1)
//---------------------------------------------------------------------
matvec_sub(lhs[ksize][AA], rhs[ksize-1][j][i], rhs[ksize][j][i]);
//---------------------------------------------------------------------
// B(ksize) = B(ksize) - C(ksize-1)*A(ksize)
// matmul_sub(AA,i,j,ksize,c,
// $ CC,i,j,ksize-1,c,BB,i,j,ksize)
//---------------------------------------------------------------------
matmul_sub(lhs[ksize][AA], lhs[ksize-1][CC], lhs[ksize][BB]);
//---------------------------------------------------------------------
// multiply rhs(ksize) by b_inverse(ksize) and copy to rhs
//---------------------------------------------------------------------
binvrhs( lhs[ksize][BB], rhs[ksize][j][i] );
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// back solve: if last cell, then generate U(ksize)=rhs(ksize)
// else assume U(ksize) is loaded in un pack backsub_info
// so just use it
// after u(kstart) will be sent to next cell
//---------------------------------------------------------------------
for (k = ksize-1; k >= 0; k--) {
for (m = 0; m < BLOCK_SIZE; m++) {
for (n = 0; n < BLOCK_SIZE; n++) {
rhs[k][j][i][m] = rhs[k][j][i][m]
- lhs[k][CC][n][m]*rhs[k+1][j][i][n];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) shared(ksize) private(i,j,k,m,n)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/BT/y_solve.c | #pragma omp parallel for default(shared) shared(jsize) private(i,j,k,m,n) | 100 | n jacobians for cell c
//---------------------------------------------------------------------
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 0; j <= jsize; j++) {
tmp1 = rho_i[k][j][i];
tmp2 = tmp1 * tmp1;
tmp3 = tmp1 * tmp2;
fjac[j][0][0] = 0.0;
fjac[j][1][0] = 0.0;
fjac[j][2][0] = 1.0;
fjac[j][3][0] = 0.0;
fjac[j][4][0] = 0.0;
fjac[j][0][1] = - ( u[k][j][i][1]*u[k][j][i][2] ) * tmp2;
fjac[j][1][1] = u[k][j][i][2] * tmp1;
fjac[j][2][1] = u[k][j][i][1] * tmp1;
fjac[j][3][1] = 0.0;
fjac[j][4][1] = 0.0;
fjac[j][0][2] = - ( u[k][j][i][2]*u[k][j][i][2]*tmp2)
+ c2 * qs[k][j][i];
fjac[j][1][2] = - c2 * u[k][j][i][1] * tmp1;
fjac[j][2][2] = ( 2.0 - c2 ) * u[k][j][i][2] * tmp1;
fjac[j][3][2] = - c2 * u[k][j][i][3] * tmp1;
fjac[j][4][2] = c2;
fjac[j][0][3] = - ( u[k][j][i][2]*u[k][j][i][3] ) * tmp2;
fjac[j][1][3] = 0.0;
fjac[j][2][3] = u[k][j][i][3] * tmp1;
fjac[j][3][3] = u[k][j][i][2] * tmp1;
fjac[j][4][3] = 0.0;
fjac[j][0][4] = ( c2 * 2.0 * square[k][j][i] - c1 * u[k][j][i][4] )
* u[k][j][i][2] * tmp2;
fjac[j][1][4] = - c2 * u[k][j][i][1]*u[k][j][i][2] * tmp2;
fjac[j][2][4] = c1 * u[k][j][i][4] * tmp1
- c2 * ( qs[k][j][i] + u[k][j][i][2]*u[k][j][i][2] * tmp2 );
fjac[j][3][4] = - c2 * ( u[k][j][i][2]*u[k][j][i][3] ) * tmp2;
fjac[j][4][4] = c1 * u[k][j][i][2] * tmp1;
njac[j][0][0] = 0.0;
njac[j][1][0] = 0.0;
njac[j][2][0] = 0.0;
njac[j][3][0] = 0.0;
njac[j][4][0] = 0.0;
njac[j][0][1] = - c3c4 * tmp2 * u[k][j][i][1];
njac[j][1][1] = c3c4 * tmp1;
njac[j][2][1] = 0.0;
njac[j][3][1] = 0.0;
njac[j][4][1] = 0.0;
njac[j][0][2] = - con43 * c3c4 * tmp2 * u[k][j][i][2];
njac[j][1][2] = 0.0;
njac[j][2][2] = con43 * c3c4 * tmp1;
njac[j][3][2] = 0.0;
njac[j][4][2] = 0.0;
njac[j][0][3] = - c3c4 * tmp2 * u[k][j][i][3];
njac[j][1][3] = 0.0;
njac[j][2][3] = 0.0;
njac[j][3][3] = c3c4 * tmp1;
njac[j][4][3] = 0.0;
njac[j][0][4] = - ( c3c4
- c1345 ) * tmp3 * (u[k][j][i][1]*u[k][j][i][1])
- ( con43 * c3c4
- c1345 ) * tmp3 * (u[k][j][i][2]*u[k][j][i][2])
- ( c3c4 - c1345 ) * tmp3 * (u[k][j][i][3]*u[k][j][i][3])
- c1345 * tmp2 * u[k][j][i][4];
njac[j][1][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][1];
njac[j][2][4] = ( con43 * c3c4 - c1345 ) * tmp2 * u[k][j][i][2];
njac[j][3][4] = ( c3c4 - c1345 ) * tmp2 * u[k][j][i][3];
njac[j][4][4] = ( c1345 ) * tmp1;
}
//---------------------------------------------------------------------
// now joacobians set, so form left hand side in y direction
//---------------------------------------------------------------------
lhsinit(lhs, jsize);
for (j = 1; j <= jsize-1; j++) {
tmp1 = dt * ty1;
tmp2 = dt * ty2;
lhs[j][AA][0][0] = - tmp2 * fjac[j-1][0][0]
- tmp1 * njac[j-1][0][0]
- tmp1 * dy1;
lhs[j][AA][1][0] = - tmp2 * fjac[j-1][1][0]
- tmp1 * njac[j-1][1][0];
lhs[j][AA][2][0] = - tmp2 * fjac[j-1][2][0]
- tmp1 * njac[j-1][2][0];
lhs[j][AA][3][0] = - tmp2 * fjac[j-1][3][0]
- tmp1 * njac[j-1][3][0];
lhs[j][AA][4][0] = - tmp2 * fjac[j-1][4][0]
- tmp1 * njac[j-1][4][0];
lhs[j][AA][0][1] = - tmp2 * fjac[j-1][0][1]
- tmp1 * njac[j-1][0][1];
lhs[j][AA][1][1] = - tmp2 * fjac[j-1][1][1]
- tmp1 * njac[j-1][1][1]
- tmp1 * dy2;
lhs[j][AA][2][1] = - tmp2 * fjac[j-1][2][1]
- tmp1 * njac[j-1][2][1];
lhs[j][AA][3][1] = - tmp2 * fjac[j-1][3][1]
- tmp1 * njac[j-1][3][1];
lhs[j][AA][4][1] = - tmp2 * fjac[j-1][4][1]
- tmp1 * njac[j-1][4][1];
lhs[j][AA][0][2] = - tmp2 * fjac[j-1][0][2]
- tmp1 * njac[j-1][0][2];
lhs[j][AA][1][2] = - tmp2 * fjac[j-1][1][2]
- tmp1 * njac[j-1][1][2];
lhs[j][AA][2][2] = - tmp2 * fjac[j-1][2][2]
- tmp1 * njac[j-1][2][2]
- tmp1 * dy3;
lhs[j][AA][3][2] = - tmp2 * fjac[j-1][3][2]
- tmp1 * njac[j-1][3][2];
lhs[j][AA][4][2] = - tmp2 * fjac[j-1][4][2]
- tmp1 * njac[j-1][4][2];
lhs[j][AA][0][3] = - tmp2 * fjac[j-1][0][3]
- tmp1 * njac[j-1][0][3];
lhs[j][AA][1][3] = - tmp2 * fjac[j-1][1][3]
- tmp1 * njac[j-1][1][3];
lhs[j][AA][2][3] = - tmp2 * fjac[j-1][2][3]
- tmp1 * njac[j-1][2][3];
lhs[j][AA][3][3] = - tmp2 * fjac[j-1][3][3]
- tmp1 * njac[j-1][3][3]
- tmp1 * dy4;
lhs[j][AA][4][3] = - tmp2 * fjac[j-1][4][3]
- tmp1 * njac[j-1][4][3];
lhs[j][AA][0][4] = - tmp2 * fjac[j-1][0][4]
- tmp1 * njac[j-1][0][4];
lhs[j][AA][1][4] = - tmp2 * fjac[j-1][1][4]
- tmp1 * njac[j-1][1][4];
lhs[j][AA][2][4] = - tmp2 * fjac[j-1][2][4]
- tmp1 * njac[j-1][2][4];
lhs[j][AA][3][4] = - tmp2 * fjac[j-1][3][4]
- tmp1 * njac[j-1][3][4];
lhs[j][AA][4][4] = - tmp2 * fjac[j-1][4][4]
- tmp1 * njac[j-1][4][4]
- tmp1 * dy5;
lhs[j][BB][0][0] = 1.0
+ tmp1 * 2.0 * njac[j][0][0]
+ tmp1 * 2.0 * dy1;
lhs[j][BB][1][0] = tmp1 * 2.0 * njac[j][1][0];
lhs[j][BB][2][0] = tmp1 * 2.0 * njac[j][2][0];
lhs[j][BB][3][0] = tmp1 * 2.0 * njac[j][3][0];
lhs[j][BB][4][0] = tmp1 * 2.0 * njac[j][4][0];
lhs[j][BB][0][1] = tmp1 * 2.0 * njac[j][0][1];
lhs[j][BB][1][1] = 1.0
+ tmp1 * 2.0 * njac[j][1][1]
+ tmp1 * 2.0 * dy2;
lhs[j][BB][2][1] = tmp1 * 2.0 * njac[j][2][1];
lhs[j][BB][3][1] = tmp1 * 2.0 * njac[j][3][1];
lhs[j][BB][4][1] = tmp1 * 2.0 * njac[j][4][1];
lhs[j][BB][0][2] = tmp1 * 2.0 * njac[j][0][2];
lhs[j][BB][1][2] = tmp1 * 2.0 * njac[j][1][2];
lhs[j][BB][2][2] = 1.0
+ tmp1 * 2.0 * njac[j][2][2]
+ tmp1 * 2.0 * dy3;
lhs[j][BB][3][2] = tmp1 * 2.0 * njac[j][3][2];
lhs[j][BB][4][2] = tmp1 * 2.0 * njac[j][4][2];
lhs[j][BB][0][3] = tmp1 * 2.0 * njac[j][0][3];
lhs[j][BB][1][3] = tmp1 * 2.0 * njac[j][1][3];
lhs[j][BB][2][3] = tmp1 * 2.0 * njac[j][2][3];
lhs[j][BB][3][3] = 1.0
+ tmp1 * 2.0 * njac[j][3][3]
+ tmp1 * 2.0 * dy4;
lhs[j][BB][4][3] = tmp1 * 2.0 * njac[j][4][3];
lhs[j][BB][0][4] = tmp1 * 2.0 * njac[j][0][4];
lhs[j][BB][1][4] = tmp1 * 2.0 * njac[j][1][4];
lhs[j][BB][2][4] = tmp1 * 2.0 * njac[j][2][4];
lhs[j][BB][3][4] = tmp1 * 2.0 * njac[j][3][4];
lhs[j][BB][4][4] = 1.0
+ tmp1 * 2.0 * njac[j][4][4]
+ tmp1 * 2.0 * dy5;
lhs[j][CC][0][0] = tmp2 * fjac[j+1][0][0]
- tmp1 * njac[j+1][0][0]
- tmp1 * dy1;
lhs[j][CC][1][0] = tmp2 * fjac[j+1][1][0]
- tmp1 * njac[j+1][1][0];
lhs[j][CC][2][0] = tmp2 * fjac[j+1][2][0]
- tmp1 * njac[j+1][2][0];
lhs[j][CC][3][0] = tmp2 * fjac[j+1][3][0]
- tmp1 * njac[j+1][3][0];
lhs[j][CC][4][0] = tmp2 * fjac[j+1][4][0]
- tmp1 * njac[j+1][4][0];
lhs[j][CC][0][1] = tmp2 * fjac[j+1][0][1]
- tmp1 * njac[j+1][0][1];
lhs[j][CC][1][1] = tmp2 * fjac[j+1][1][1]
- tmp1 * njac[j+1][1][1]
- tmp1 * dy2;
lhs[j][CC][2][1] = tmp2 * fjac[j+1][2][1]
- tmp1 * njac[j+1][2][1];
lhs[j][CC][3][1] = tmp2 * fjac[j+1][3][1]
- tmp1 * njac[j+1][3][1];
lhs[j][CC][4][1] = tmp2 * fjac[j+1][4][1]
- tmp1 * njac[j+1][4][1];
lhs[j][CC][0][2] = tmp2 * fjac[j+1][0][2]
- tmp1 * njac[j+1][0][2];
lhs[j][CC][1][2] = tmp2 * fjac[j+1][1][2]
- tmp1 * njac[j+1][1][2];
lhs[j][CC][2][2] = tmp2 * fjac[j+1][2][2]
- tmp1 * njac[j+1][2][2]
- tmp1 * dy3;
lhs[j][CC][3][2] = tmp2 * fjac[j+1][3][2]
- tmp1 * njac[j+1][3][2];
lhs[j][CC][4][2] = tmp2 * fjac[j+1][4][2]
- tmp1 * njac[j+1][4][2];
lhs[j][CC][0][3] = tmp2 * fjac[j+1][0][3]
- tmp1 * njac[j+1][0][3];
lhs[j][CC][1][3] = tmp2 * fjac[j+1][1][3]
- tmp1 * njac[j+1][1][3];
lhs[j][CC][2][3] = tmp2 * fjac[j+1][2][3]
- tmp1 * njac[j+1][2][3];
lhs[j][CC][3][3] = tmp2 * fjac[j+1][3][3]
- tmp1 * njac[j+1][3][3]
- tmp1 * dy4;
lhs[j][CC][4][3] = tmp2 * fjac[j+1][4][3]
- tmp1 * njac[j+1][4][3];
lhs[j][CC][0][4] = tmp2 * fjac[j+1][0][4]
- tmp1 * njac[j+1][0][4];
lhs[j][CC][1][4] = tmp2 * fjac[j+1][1][4]
- tmp1 * njac[j+1][1][4];
lhs[j][CC][2][4] = tmp2 * fjac[j+1][2][4]
- tmp1 * njac[j+1][2][4];
lhs[j][CC][3][4] = tmp2 * fjac[j+1][3][4]
- tmp1 * njac[j+1][3][4];
lhs[j][CC][4][4] = tmp2 * fjac[j+1][4][4]
- tmp1 * njac[j+1][4][4]
- tmp1 * dy5;
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// performs guaussian elimination on this cell.
//
// assumes that unpacking routines for non-first cells
// preload C' and rhs' from previous cell.
//
// assumed send happens outside this routine, but that
// c'(JMAX) and rhs'(JMAX) will be sent to next cell
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// multiply c[k][0][i] by b_inverse and copy back to c
// multiply rhs(0) by b_inverse(0) and copy to rhs
//---------------------------------------------------------------------
binvcrhs( lhs[0][BB], lhs[0][CC], rhs[k][0][i] );
//---------------------------------------------------------------------
// begin inner most do loop
// do all the elements of the cell unless last
//---------------------------------------------------------------------
for (j = 1; j <= jsize-1; j++) {
//-------------------------------------------------------------------
// subtract A*lhs_vector(j-1) from lhs_vector(j)
//
// rhs(j) = rhs(j) - A*rhs(j-1)
//-------------------------------------------------------------------
matvec_sub(lhs[j][AA], rhs[k][j-1][i], rhs[k][j][i]);
//-------------------------------------------------------------------
// B(j) = B(j) - C(j-1)*A(j)
//-------------------------------------------------------------------
matmul_sub(lhs[j][AA], lhs[j-1][CC], lhs[j][BB]);
//-------------------------------------------------------------------
// multiply c[k][j][i] by b_inverse and copy back to c
// multiply rhs[k][0][i] by b_inverse[k][0][i] and copy to rhs
//-------------------------------------------------------------------
binvcrhs( lhs[j][BB], lhs[j][CC], rhs[k][j][i] );
}
//---------------------------------------------------------------------
// rhs(jsize) = rhs(jsize) - A*rhs(jsize-1)
//---------------------------------------------------------------------
matvec_sub(lhs[jsize][AA], rhs[k][jsize-1][i], rhs[k][jsize][i]);
//---------------------------------------------------------------------
// B(jsize) = B(jsize) - C(jsize-1)*A(jsize)
// matmul_sub(AA,i,jsize,k,c,
// $ CC,i,jsize-1,k,c,BB,i,jsize,k)
//---------------------------------------------------------------------
matmul_sub(lhs[jsize][AA], lhs[jsize-1][CC], lhs[jsize][BB]);
//---------------------------------------------------------------------
// multiply rhs(jsize) by b_inverse(jsize) and copy to rhs
//---------------------------------------------------------------------
binvrhs( lhs[jsize][BB], rhs[k][jsize][i] );
//---------------------------------------------------------------------
// back solve: if last cell, then generate U(jsize)=rhs(jsize)
// else assume U(jsize) is loaded in un pack backsub_info
// so just use it
// after u(jstart) will be sent to next cell
//---------------------------------------------------------------------
for (j = jsize-1; j >= 0; j--) {
for (m = 0; m < BLOCK_SIZE; m++) {
for (n = 0; n < BLOCK_SIZE; n++) {
rhs[k][j][i][m] = rhs[k][j][i][m]
- lhs[j][CC][n][m]*rhs[k][j+1][i][n];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) shared(jsize) private(i,j,k,m,n)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/CG/cg.c | #pragma omp parallel for default(shared) private(j) \ | 100 | ---------------------------------------------------
norm_temp1 = 0.0;
norm_temp2 = 0.0;
<LOOP-START>reduction(+:norm_temp1,norm_temp2)
for (j = 0; j < lastcol - firstcol + 1; j++) {
norm_temp1 = norm_temp1 + x[j] * z[j];
norm_temp2 = norm_temp2 + z[j] * z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/CG/cg.c | #pragma omp parallel for default(shared) private(j) | 100 | alize z to obtain x
//---------------------------------------------------------------------
<LOOP-START>for (j = 0; j < lastcol - firstcol + 1; j++) {
x[j] = norm_temp2 * z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/CG/cg.c | #pragma omp parallel for default(shared) private(i) | 100 | ector to (1, 1, .... 1)
//---------------------------------------------------------------------
<LOOP-START>for (i = 0; i < NA+1; i++) {
x[i] = 1.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/CG/cg.c | #pragma omp parallel for default(shared) private(j) \ | 100 | ---------------------------------------------------
norm_temp1 = 0.0;
norm_temp2 = 0.0;
<LOOP-START>reduction(+:norm_temp1,norm_temp2)
for (j = 0; j < lastcol - firstcol + 1; j++) {
norm_temp1 = norm_temp1 + x[j]*z[j];
norm_temp2 = norm_temp2 + z[j]*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/CG/cg.c | #pragma omp parallel for default(shared) private(j) | 100 | alize z to obtain x
//---------------------------------------------------------------------
<LOOP-START>for (j = 0; j < lastcol - firstcol + 1; j++) {
x[j] = norm_temp2 * z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/LU/setiv.c | #pragma omp parallel for default(shared) private(i,j,k,m,pxi,peta,pzeta, \ | 100 | pzeta;
double ue_1jk[5], ue_nx0jk[5], ue_i1k[5];
double ue_iny0k[5], ue_ij1[5], ue_ijnz[5];
<LOOP-START>xi,eta,zeta,ue_ijnz,ue_ij1,ue_iny0k,ue_i1k,ue_nx0jk,ue_1jk) \
shared(nx0,ny0,nz)
for (k = 1; k < nz - 1; k++) {
zeta = ( (double)k ) / (nz-1);
for (j = 1; j < ny - 1; j++) {
eta = ( (double)j ) / (ny0-1);
for (i = 1; i < nx - 1; i++) {
xi = ( (double)i ) / (nx0-1);
exact(0, j, k, ue_1jk);
exact(nx0-1, j, k, ue_nx0jk);
exact(i, 0, k, ue_i1k);
exact(i, ny0-1, k, ue_iny0k);
exact(i, j, 0, ue_ij1);
exact(i, j, nz-1, ue_ijnz);
for (m = 0; m < 5; m++) {
pxi = ( 1.0 - xi ) * ue_1jk[m]
+ xi * ue_nx0jk[m];
peta = ( 1.0 - eta ) * ue_i1k[m]
+ eta * ue_iny0k[m];
pzeta = ( 1.0 - zeta ) * ue_ij1[m]
+ zeta * ue_ijnz[m];
u[k][j][i][m] = pxi + peta + pzeta
- pxi * peta - peta * pzeta - pzeta * pxi
+ pxi * peta * pzeta;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,m,pxi,peta,pzeta, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k) | 100 | lex (*)[d2][d1+1])ou1;
double (*twiddle)[d2][d1+1] = (double (*)[d2][d1+1])ot;
int i, j, k;
<LOOP-START>for (k = 0; k < d3; k++) {
for (j = 0; j < d2; j++) {
for (i = 0; i < d1; i++) {
u0[k][j][i] = dcmplx(0.0, 0.0);
u1[k][j][i] = dcmplx(0.0, 0.0);
twiddle[k][j][i] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k) | 100 | lex (*)[d2][d1+1])ou1;
double (*twiddle)[d2][d1+1] = (double (*)[d2][d1+1])ot;
int i, j, k;
<LOOP-START>for (k = 0; k < d3; k++) {
for (j = 0; j < d2; j++) {
for (i = 0; i < d1; i++) {
u0[k][j][i] = dcmplx_mul2(u0[k][j][i], twiddle[k][j][i]);
u1[k][j][i] = u0[k][j][i];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(k,j,x0) | 100 | n one square at a time.
//---------------------------------------------------------------------
<LOOP-START>for (k = 0; k < dims[2]; k++) {
x0 = starts[k];
for (j = 0; j < dims[1]; j++) {
vranlc(2*NX, &x0, A, (double *)&u0[k][j][0]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(k,j,x0)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k,kk,kk2,jj,kj2,ii) | 100 | ----------------------------------------------------------------
ap = -4.0 * ALPHA * PI * PI;
<LOOP-START>for (k = 0; k < dims[2]; k++) {
kk = ((k + NZ/2) % NZ) - NZ/2;
kk2 = kk*kk;
for (j = 0; j < dims[1]; j++) {
jj = ((j + NY/2) % NY) - NY/2;
kj2 = jj*jj + kk2;
for (i = 0; i < dims[0]; i++) {
ii = ((i + NX/2) % NX) - NX/2;
twiddle[k][j][i] = exp(ap * (double)(ii*ii+kj2));
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,kk,kk2,jj,kj2,ii)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k,jj) | 100 | int logd1;
int i, j, k, jj;
logd1 = ilog2(d1);
if (timers_enabled) timer_start(T_fftx);
<LOOP-START>for (k = 0; k < d3; k++) {
for (jj = 0; jj <= d2 - fftblock; jj += fftblock) {
for (j = 0; j < fftblock; j++) {
for (i = 0; i < d1; i++) {
ty1[i][j] = x[k][j+jj][i];
}
}
cfftz(is, logd1, d1, ty1, ty2);
for (j = 0; j < fftblock; j++) {
for (i = 0; i < d1; i++) {
xout[k][j+jj][i] = ty1[i][j];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,jj)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k,ii) | 100 | int logd2;
int i, j, k, ii;
logd2 = ilog2(d2);
if (timers_enabled) timer_start(T_ffty);
<LOOP-START>for (k = 0; k < d3; k++) {
for (ii = 0; ii <= d1 - fftblock; ii += fftblock) {
for (j = 0; j < d2; j++) {
for (i = 0; i < fftblock; i++) {
ty1[j][i] = x[k][j][i+ii];
}
}
cfftz(is, logd2, d2, ty1, ty2);
for (j = 0; j < d2; j++) {
for (i = 0; i < fftblock; i++) {
xout[k][j][i+ii] = ty1[j][i];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,ii)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/FT/ft.c | #pragma omp parallel for default(shared) private(i,j,k,ii) | 100 | int logd3;
int i, j, k, ii;
logd3 = ilog2(d3);
if (timers_enabled) timer_start(T_fftz);
<LOOP-START>for (j = 0; j < d2; j++) {
for (ii = 0; ii <= d1 - fftblock; ii += fftblock) {
for (k = 0; k < d3; k++) {
for (i = 0; i < fftblock; i++) {
ty1[k][i] = x[k][j][i+ii];
}
}
cfftz(is, logd3, d3, ty1, ty2);
for (k = 0; k < d3; k++) {
for (i = 0; i < fftblock; i++) {
xout[k][j][i+ii] = ty1[k][i];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,ii)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | --------------------------------------------------
void reciprocal(double a[], int n)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = 1.0/a[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | -----------------------------------
void r_init_omp(double a[], int n, double _const)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = _const;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | ----------------------------------------
void nr_init_omp(int a[], int n, int _const)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = _const;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | ---------------------------------
void l_init_omp(logical a[], int n, logical _const)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = _const;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | -------------------------------
void adds2m1(double a[], double b[], double c1, int n)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = a[i]+c1*b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | -------------------------------
void adds1m1(double a[], double b[], double c1, int n)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = c1*a[i]+b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | --------------------------------------------
void col2(double a[], double b[], int n)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = a[i]*b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i) | 100 | ---------------------------------------------
void add2(double a[], double b[], int n)
{
int i;
<LOOP-START>for (i = 0; i < n; i++) {
a[i] = a[i]+b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(i,j,k,isize,ieltotal,iel) \ | 100 | ------
double calc_norm()
{
double total, ieltotal;
int iel, k, j, i, isize;
total = 0.0;
<LOOP-START>reduction(+:total)
for (iel = 0; iel < nelt; iel++) {
ieltotal = 0.0;
isize = size_e[iel];
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
ieltotal = ieltotal+ta1[iel][k][j][i]*w3m1[k][j][i]
*jacm1_s[isize][k][j][i];
}
}
}
total = total+ieltotal;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,isize,ieltotal,iel) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(ahead,ii,iel) | 100 | log+1;
} while (iel < nelt);
ntemp = 1;
for (i = 0; i < nellog; i++) {
n1 = ntemp*2;
<LOOP-START>for (iel = n1; iel <= nelt; iel += n1) {
ahead = frontier[iel-ntemp-1];
for (ii = ntemp-1; ii >= 0; ii--) {
frontier[iel-ii-1] = frontier[iel-ii-1]+ahead;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ahead,ii,iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/utils.c | #pragma omp parallel for default(shared) private(ii) | 100 | +1)*n1;
ntemp1 = iel-nelt;
if (ntemp1 < ntemp) {
ahead = frontier[iel-ntemp-1];
<LOOP-START>for (ii = ntemp-1; ii >= ntemp1; ii--) {
frontier[iel-ii-1] = frontier[iel-ii-1]+ahead;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ii)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/transfer_au.c | #pragma omp parallel for default(shared) private(i) | 100 | --------------------------------
void init_locks()
{
int i;
// initialize locks in parallel
<LOOP-START>for (i = 0; i < 8*LELT; i++) {
omp_init_lock(&tlock[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/transfer_au.c | #pragma omp parallel for default(shared) private(il,j,ig,i,col,ije2,ije1, \ | 100 | 2, col, i, j, ig, il;
// zero out tx on element boundaries
col2(tx, (double *)tmult, ntot);
<LOOP-START>ig4,ig3,ig2,ig1,nnje,il4,il3,il2,il1,iface,ie,tmp)
for (ie = 0; ie < nelt; ie++) {
for (iface = 0; iface < NSIDES; iface++) {
// get the collocation point index of the four local corners on the
// face iface of element ie
il1 = idel[ie][iface][0][0];
il2 = idel[ie][iface][0][LX1-1];
il3 = idel[ie][iface][LX1-1][0];
il4 = idel[ie][iface][LX1-1][LX1-1];
// get the mortar indices of the four local corners
ig1 = idmo[ie][iface][0][0][0][0];
ig2 = idmo[ie][iface][1][0][0][LX1-1];
ig3 = idmo[ie][iface][0][1][LX1-1][0];
ig4 = idmo[ie][iface][1][1][LX1-1][LX1-1];
// copy the value from tmor to tx for these four local corners
tx[il1] = tmor[ig1];
tx[il2] = tmor[ig2];
tx[il3] = tmor[ig3];
tx[il4] = tmor[ig4];
// nnje=1 for conforming faces, nnje=2 for nonconforming faces
if (cbc[ie][iface] == 3) {
nnje = 2;
} else {
nnje = 1;
}
// for nonconforming faces
if (nnje == 2) {
// nonconforming faces have four pieces of mortar, first map them to
// two intermediate mortars, stored in tmp
r_init((double *)tmp, LX1*LX1*2, 0.0);
for (ije1 = 0; ije1 < nnje; ije1++) {
for (ije2 = 0; ije2 < nnje; ije2++) {
for (col = 0; col < LX1; col++) {
// in each row col, when coloumn i=1 or LX1, the value
// in tmor is copied to tmp
i = v_end[ije2];
ig = idmo[ie][iface][ije2][ije1][col][i];
tmp[ije1][col][i] = tmor[ig];
// in each row col, value in the interior three collocation
// points is computed by apply mapping matrix qbnew to tmor
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][col][i];
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije2][ije1][col][j];
tmp[ije1][col][i] = tmp[ije1][col][i] +
qbnew[ije2][j][i-1]*tmor[ig];
}
}
}
}
}
// mapping from two pieces of intermediate mortar tmp to element
// face tx
for (ije1 = 0; ije1 < nnje; ije1++) {
// the first column, col=0, is an edge of face iface.
// the value on the three interior collocation points, tx, is
// computed by applying mapping matrices qbnew to tmp.
// the mapping result is divided by 2, because there will be
// duplicated contribution from another face sharing this edge.
col = 0;
for (i = 1; i < LX1-1; i++) {
il= idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]*
tmp[ije1][j][col]*0.5;
}
}
// for column 1 ~ lx-2
for (col = 1; col < LX1-1; col++) {
//when i=0 or LX1-1, the collocation points are also on an edge of
// the face, so the mapping result also needs to be divided by 2
i = v_end[ije1];
il = idel[ie][iface][i][col];
tx[il] = tx[il]+tmp[ije1][i][col]*0.5;
// compute the value at interior collocation points in
// columns 1 ~ LX1-1
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]* tmp[ije1][j][col];
}
}
}
// same as col=0
col = LX1-1;
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]*
tmp[ije1][j][col]*0.5;
}
}
}
// for conforming faces
} else {
// face interior
for (col = 1; col < LX1-1; col++) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][col][i];
ig = idmo[ie][iface][0][0][col][i];
tx[il] = tmor[ig];
}
}
// edges of conforming faces
// if local edge 0 is a nonconforming edge
if (idmo[ie][iface][0][0][0][LX1-1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][0][i];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije1][0][0][j];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 0 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][0][i];
ig = idmo[ie][iface][0][0][0][i];
tx[il] = tmor[ig];
}
}
// if local edge 1 is a nonconforming edge
if (idmo[ie][iface][1][0][1][LX1-1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][LX1-1];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][1][ije1][j][LX1-1];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 1 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][LX1-1];
ig = idmo[ie][iface][0][0][i][LX1-1];
tx[il] = tmor[ig];
}
}
// if local edge 2 is a nonconforming edge
if (idmo[ie][iface][0][1][LX1-1][1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][LX1-1][i];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije1][1][LX1-1][j];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 2 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][LX1-1][i];
ig = idmo[ie][iface][0][0][LX1-1][i];
tx[il] = tmor[ig];
}
}
// if local edge 3 is a nonconforming edge
if (idmo[ie][iface][0][0][LX1-1][0] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][0];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][0][ije1][j][0];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 3 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][0];
ig = idmo[ie][iface][0][0][i][0];
tx[il] = tmor[ig];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(il,j,ig,i,col,ije2,ije1, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel,sumcb,ij1,ij2, \ | 100 | mortar point.
// VERTICES
count = -1;
// assign mortar point indices to element vertices
<LOOP-START>cb,cb1,cb2,ntemp,ntemp1)
for (iel = 0; iel < nelt; iel++) {
// first calculate how many new mortar indices will be generated for
// each element.
// For each element, at least one vertex (vertex 7) will be new mortar
// point. All possible new mortar points will be on face 1,3 or 5. By
// checking the type of these three faces, we are able to tell
// how many new mortar vertex points will be generated in each element.
cb = cbc[iel][5];
cb1 = cbc[iel][3];
cb2 = cbc[iel][1];
// For different combinations of the type of these three faces,
// we group them into 27 configurations.
// For different face types we assign the following integers:
// 1 for type 2 or 3
// 2 for type 0
// 5 for type 1
// By summing these integers for faces 1,3 and 5, sumcb will have
// 10 different numbers indicating 10 different combinations.
sumcb = 0;
if (cb == 2 || cb == 3) {
sumcb = sumcb+1;
} else if (cb == 0) {
sumcb = sumcb+2;
} else if (cb == 1) {
sumcb = sumcb+5;
}
if (cb1 == 2 || cb1 == 3) {
sumcb = sumcb+1;
} else if (cb1 == 0) {
sumcb = sumcb+2;
} else if (cb1 == 1) {
sumcb = sumcb+5;
}
if (cb2 == 2 || cb2 == 3) {
sumcb = sumcb+1;
} else if (cb2 == 0) {
sumcb = sumcb+2;
} else if (cb2 == 1) {
sumcb = sumcb+5;
}
// compute newc[iel]
// newc[iel] records how many new mortar indices will be generated
// for element iel
// vassign[iel][i] records the element vertex of the i'th new mortar
// vertex point for element iel. e.g. vassign[iel][1]=8 means
// the 2nd new mortar vertex point generated on element
// iel is iel's 8th vertex.
if (sumcb == 3) {
// the three face types for face 1,3, and 5 are 2 2 2
newc[iel] = 1;
vassign[iel][0] = 7;
} else if (sumcb == 4) {
// the three face types for face 1,3 and 5 are 2 2 0 (not
// necessarily in this order)
newc[iel] = 2;
if (cb == 0) {
vassign[iel][0] = 3;
} else if (cb1 == 0) {
vassign[iel][0] = 5;
} else if (cb2 == 0) {
vassign[iel][0] = 6;
}
vassign[iel][1] = 7;
} else if (sumcb == 7) {
// the three face types for face 1,3 and 5 are 2 2 1 (not
// necessarily in this order)
if (cb == 1) {
ij1 = ijel[iel][5][0];
ij2 = ijel[iel][5][1];
if (ij1 == 0 && ij2 == 0) {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
} else if (ij1 == 0 && ij2 == 1) {
ntemp = sje[iel][5][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
}
} else if (ij1 == 1 && ij2 == 0) {
ntemp = sje[iel][5][0][0];
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
}
} else {
newc[iel] = 1;
vassign[iel][0] = 7;
}
} else if (cb1 == 1) {
ij1 = ijel[iel][3][0];
ij2 = ijel[iel][3][1];
if (ij1 == 0 && ij2 == 0) {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
} else if (ij1 == 0 && ij2 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
}
} else if (ij1 == 1 && ij2 == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
}
} else {
newc[iel] = 1;
vassign[iel][0] = 7;
}
} else if (cb2 == 1) {
ij1 = ijel[iel][1][0];
ij2 = ijel[iel][1][1];
if (ij1 == 0 && ij2 == 0) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else if (ij1 == 0 && ij2 == 1) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
}
} else if (ij1 == 1 && ij2 == 0) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
}
} else {
newc[iel] = 1;
vassign[iel][0] = 7;
}
}
} else if (sumcb == 5) {
// the three face types for face 1,3 and 5 are 2/3 0 0 (not
// necessarily in this order)
newc[iel] = 4;
if (cb == 2 || cb == 3) {
vassign[iel][0] = 4;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else if (cb1 == 2 || cb1 == 3) {
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else if (cb2 == 2 || cb2 == 3) {
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 7;
}
} else if (sumcb == 8) {
// the three face types for face 1,3 and 5 are 2 0 1 (not
// necessarily in this order)
// if face 2 of type 1
if (cb == 1) {
if (cb1 == 2 || cb1 == 3) {
ij1 = ijel[iel][5][0];
if (ij1 == 0) {
newc[iel] = 4;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else {
ntemp = sje[iel][5][0][0];
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
} else if (cb2 == 2 || cb2 == 3) {
if (ijel[iel][5][1] == 0) {
newc[iel] = 4;
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 7;
} else {
ntemp = sje[iel][5][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 5;
vassign[iel][2] = 7;
}
}
}
// if face 4 of type 1
} else if (cb1 == 1) {
if (cb == 2 || cb == 3) {
ij1 = ijel[iel][3][0];
ij2 = ijel[iel][3][1];
if (ij1 == 0 && ij2 == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][1] == 3 && sje[ntemp][1][0][0] < iel) {
newc[iel] = 3;
vassign[iel][0] = 5;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
} else {
newc[iel] = 4;
vassign[iel][0] = 4;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
}
} else if (ij1 == 0 && ij2 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
newc[iel] = 3;
vassign[iel][0] = 4;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
} else {
newc[iel] = 4;
vassign[iel][0] = 4;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
}
} else if (ij1 == 1 && ij2 == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 5;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
} else if (ij1 == 1 && ij2 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 4;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
} else {
if (ijel[iel][3][1] == 0) {
newc[iel] = 4;
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 7;
} else {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 5;
vassign[iel][2] = 7;
}
}
}
// if face 6 of type 1
} else if (cb2 == 1) {
if (cb == 2 || cb == 3) {
if (ijel[iel][1][0] == 0) {
newc[iel] = 4;
vassign[iel][0] = 4;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 5;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
} else {
if (ijel[iel][1][1] == 0) {
newc[iel] = 4;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
}
}
} else if (sumcb == 11) {
// the three face type for face 2,4 and 6 are 2 1 1(not
// necessarily in this order)
if (cb == 2 || cb == 3) {
if (ijel[iel][3][0] == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][1] == 3 && sje[ntemp][1][0][0] < iel) {
newc[iel] = 3;
vassign[iel][0] = 5;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
} else {
newc[iel] = 4;
vassign[iel][0] = 4;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
}
// if ijel[iel][3][0]=1
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] < iel) {
ntemp1 = sje[iel][3][0][0];
if (cbc[ntemp1][4] == 3 && sje[ntemp1][4][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
}
} else {
ntemp1 = sje[iel][3][0][0];
if (cbc[ntemp1][4] == 3 && sje[ntemp1][4][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 5;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
}
} else if (cb1 == 2 || cb1 == 3) {
if (ijel[iel][1][1] == 0) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] < iel) {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
} else {
newc[iel] = 4;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
}
// if ijel[iel][1][1]=1
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] < iel) {
ntemp1 = sje[iel][5][0][0];
if (cbc[ntemp1][2] == 3 && sje[ntemp1][2][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
}
} else {
ntemp1 = sje[iel][5][0][0];
if (cbc[ntemp1][2] == 3 && sje[ntemp1][2][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 6;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 6;
vassign[iel][2] = 7;
}
}
}
} else if (cb2 == 2 || cb2 == 3) {
if (ijel[iel][5][1] == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] < iel) {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 5;
vassign[iel][2] = 7;
} else {
newc[iel] = 4;
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 7;
}
// if ijel[iel][5][1]=1
} else {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] < iel) {
ntemp1 = sje[iel][5][0][0];
if (cbc[ntemp1][0] == 3 && sje[ntemp1][0][0][0] < iel) {
newc[iel] = 1;
vassign[iel][0] = 7;
} else {
newc[iel] = 2;
vassign[iel][0] = 3;
vassign[iel][1] = 7;
}
} else {
ntemp1 = sje[iel][5][0][0];
if (cbc[ntemp1][0] == 3 && sje[ntemp1][0][0][0] < iel) {
newc[iel] = 2;
vassign[iel][0] = 5;
vassign[iel][1] = 7;
} else {
newc[iel] = 3;
vassign[iel][0] = 3;
vassign[iel][1] = 5;
vassign[iel][2] = 7;
}
}
}
}
} else if (sumcb == 6) {
// the three face type for face 1,3 and 5 are 0 0 0(not
// necessarily in this order)
newc[iel] = 8;
vassign[iel][0] = 0;
vassign[iel][1] = 1;
vassign[iel][2] = 2;
vassign[iel][3] = 3;
vassign[iel][4] = 4;
vassign[iel][5] = 5;
vassign[iel][6] = 6;
vassign[iel][7] = 7;
} else if (sumcb == 9) {
// the three face type for face 1,3 and 5 are 0 0 1(not
// necessarily in this order)
newc[iel] = 7;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 4;
vassign[iel][4] = 5;
vassign[iel][5] = 6;
vassign[iel][6] = 7;
} else if (sumcb == 12) {
// the three face type for face 1,3 and 5 are 0 1 1(not
// necessarily in this order)
if (cb == 0) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][3] == 3 && sje[ntemp][3][0][0] < iel) {
newc[iel] = 6;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 5;
vassign[iel][4] = 6;
vassign[iel][5] = 7;
} else {
newc[iel] = 7;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 4;
vassign[iel][4] = 5;
vassign[iel][5] = 6;
vassign[iel][6] = 7;
}
} else if (cb1 == 0) {
newc[iel] = 7;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 4;
vassign[iel][4] = 5;
vassign[iel][5] = 6;
vassign[iel][6] = 7;
} else if (cb2 == 0) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] < iel) {
newc[iel] = 6;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 4;
vassign[iel][3] = 5;
vassign[iel][4] = 6;
vassign[iel][5] = 7;
} else {
newc[iel] = 7;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 4;
vassign[iel][4] = 5;
vassign[iel][5] = 6;
vassign[iel][6] = 7;
}
}
} else if (sumcb == 15) {
// the three face type for face 1,3 and 5 are 1 1 1(not
// necessarily in this order)
ntemp = sje[iel][3][0][0];
ntemp1 = sje[iel][1][0][0];
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] < iel) {
if (cbc[ntemp][1] == 3 && sje[ntemp][1][0][0] < iel) {
if (cbc[ntemp1][5] == 3 && sje[ntemp1][5][0][0] < iel) {
newc[iel] = 4;
vassign[iel][0] = 3;
vassign[iel][1] = 5;
vassign[iel][2] = 6;
vassign[iel][3] = 7;
} else {
newc[iel] = 5;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 6;
vassign[iel][4] = 7;
}
} else {
if (cbc[ntemp1][5] == 3 && sje[ntemp1][5][0][0] < iel) {
newc[iel] = 5;
vassign[iel][0] = 3;
vassign[iel][1] = 4;
vassign[iel][2] = 5;
vassign[iel][3] = 6;
vassign[iel][4] = 7;
} else {
newc[iel] = 6;
vassign[iel][0] = 2;
vassign[iel][1] = 3;
vassign[iel][2] = 4;
vassign[iel][3] = 5;
vassign[iel][4] = 6;
vassign[iel][5] = 7;
}
}
} else {
if (cbc[ntemp][1] == 3 && sje[ntemp][1][0][0] < iel) {
if (cbc[ntemp1][5] == 3 && sje[ntemp1][5][0][0] < iel) {
newc[iel] = 5;
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 5;
vassign[iel][3] = 6;
vassign[iel][4] = 7;
} else {
newc[iel] = 6;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 5;
vassign[iel][4] = 6;
vassign[iel][5] = 7;
}
} else {
if (cbc[ntemp1][5] == 3 && sje[ntemp1][5][0][0] < iel) {
newc[iel] = 6;
vassign[iel][0] = 1;
vassign[iel][1] = 3;
vassign[iel][2] = 4;
vassign[iel][3] = 5;
vassign[iel][4] = 6;
vassign[iel][5] = 7;
} else {
newc[iel] = 7;
vassign[iel][0] = 1;
vassign[iel][1] = 2;
vassign[iel][2] = 3;
vassign[iel][3] = 4;
vassign[iel][4] = 5;
vassign[iel][5] = 6;
vassign[iel][6] = 7;
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,sumcb,ij1,ij2, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel) | 100 | indices are to be generated from element 0 to iel.
// front[iel]=newc[0]+newc[1]+...+newc[iel]
<LOOP-START>for (iel = 0; iel < nelt; iel++) {
front[iel] = newc[iel];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel,i,count) | 100 | tar point index of it will only
// be generated on the element with the lowest element index.
<LOOP-START>for (iel = 0; iel < nelt; iel++) {
// compute the starting vertex mortar point index in element iel
front[iel] = front[iel]-newc[iel];
for (i = 0; i < newc[iel]; i++) {
// count is the new mortar index number, which will be assigned
// to a vertex of iel and broadcast to all other elements sharing
// this vertex point.
count = front[iel]+i;
mortar_vertex(vassign[iel][i], iel, count);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,i,count)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel,cb1,cb2,cb3,cb4,cb5 \ | 100 | of iel is smaller than
// that of its neighbor connected, neighbored by edge n only
<LOOP-START>,cb6,ntemp)
for (iel = 0; iel < nelt; iel++) {
newc[iel] = 0;
newe[iel] = 0;
newi[iel] = 0;
cb1 = cbc[iel][0];
cb2 = cbc[iel][1];
cb3 = cbc[iel][2];
cb4 = cbc[iel][3];
cb5 = cbc[iel][4];
cb6 = cbc[iel][5];
// on face 6
if (cb6 == 0) {
if (cb4 == 0 || cb4 == 1) {
// if face 6 is of type 0 and face 4 is of type 0 or type 1, the edge
// shared by face 4 and 6 (edge 10) will generate new mortar point
// indices.
newe[iel] = newe[iel]+1;
eassign[iel][10] = true;
}
if (cb1 != 3) {
// if face 1 is of type 3, the edge shared by face 6 and 1 (edge 0)
// will generate new mortar points indices.
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
}
if (cb3 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
}
if (cb2 == 0 || cb2 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][4] = true;
}
} else if (cb6 == 1) {
if (cb4 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][10] = true;
} else if (cb4 == 1) {
// If face 6 and face 4 both are of type 1, ntemp is the neighbor
// element on face 4.
ntemp = sje[iel][3][0][0];
// if ntemp's face 6 is not noncoforming or the neighbor element
// of ntemp on face 6 has an element index larger than iel, the
// edge shared by face 6 and 4 (edge 10) will generate new mortar
// point indices.
if (cbc[ntemp][5] != 3 || sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][10] = true;
// if the face 6 of ntemp is of type 2
if (cbc[ntemp][5] == 2) {
// The neighbor element of iel, neighbored by edge 10, is
// sje[ntemp][5][0][0] (the neighbor element of ntemp on ntemp's
// face 6).
diagn[iel][10][0] = sje[ntemp][5][0][0];
// The neighbor element of iel, neighbored by edge 10 shares
// the ijel[iel][5][1] part of edge 10 of iel
diagn[iel][10][1] = ijel[iel][5][1];
// edge 9 of element sje[ntemp][5][0][0] (the neighbor element of
// ntemp on ntemp's face 6) is a nonconforming edge
ncon_edge[sje[ntemp][5][0][0]][9] = true;
// if_1_edge[iel][n]=true indicates that iel is of a smaller
//size than its neighbor element, neighbored by edge n of iel only.
if_1_edge[iel][10] = true;
}
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] > iel) {
diagn[iel][10][0] = sje[ntemp][5][ijel[iel][5][1]][1];
}
}
}
if (cb1 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
} else if (cb1 == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][5] != 3 || sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
if (cbc[ntemp][5] == 2) {
diagn[iel][0][0] = sje[ntemp][5][0][0];
diagn[iel][0][1] = ijel[iel][5][0];
ncon_edge[sje[ntemp][5][0][0]][6] = true;
if_1_edge[iel][0] = true;
}
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] > iel) {
diagn[iel][0][0] = sje[ntemp][5][0][ijel[iel][5][0]];
}
}
} else if (cb1 == 2) {
if (ijel[iel][5][1] == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][5] == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
// if cbc[ntemp][5]=2
} else {
if (sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
diagn[iel][0][0] = sje[ntemp][5][0][0];
}
}
} else {
newe[iel] = newe[iel]+1;
eassign[iel][0] = true;
}
}
if (cb3 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
} else if (cb3 == 1) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][5] != 3 || sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
if (cbc[ntemp][5] == 2) {
diagn[iel][8][0] = sje[ntemp][5][0][0];
diagn[iel][8][1] = ijel[iel][5][1];
ncon_edge[sje[ntemp][5][0][0]][11] = true;
if_1_edge[iel][8] = true;
}
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] > iel) {
diagn[iel][8][0] = sje[ntemp][5][ijel[iel][5][1]][1];
}
}
} else if (cb3 == 2) {
if (ijel[iel][5][0] == 1) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][5] == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
// if cbc[ntemp][5]=2
} else {
if (sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
diagn[iel][8][0] = sje[ntemp][5][0][0];
}
}
} else {
newe[iel] = newe[iel]+1;
eassign[iel][8] = true;
}
}
if (cb2 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][4] = true;
} else if (cb2 == 1) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][5] != 3 || sje[ntemp][5][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][4] = true;
if (cbc[ntemp][5] == 2) {
diagn[iel][4][0] = sje[ntemp][5][0][0];
diagn[iel][4][1] = ijel[iel][5][0];
ncon_edge[sje[ntemp][5][0][0]][2] = true;
if_1_edge[iel][4] = true;
}
if (cbc[ntemp][5] == 3 && sje[ntemp][5][0][0] > iel) {
diagn[iel][8][0] = sje[ntemp][5][ijel[iel][5][1]][1];
}
}
}
}
// one face 4
if (cb4 == 0) {
if (cb1 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][3] = true;
}
if (cb5 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][11] = true;
}
if (cb2 == 0 || cb2 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][7] = true;
}
} else if (cb4 == 1) {
if (cb1 == 2) {
if (ijel[iel][3][1] == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][3] = true;
} else {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] != 3 || sje[ntemp][0][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][3] = true;
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] > iel) {
diagn[iel][3][0] = sje[ntemp][0][1][ijel[iel][3][0]];
}
}
}
} else if (cb1 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][3] = true;
} else if (cb1 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][0] != 3 || sje[ntemp][0][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][3] = true;
if (cbc[ntemp][0] == 2) {
diagn[iel][3][0] = sje[ntemp][0][0][0];
diagn[iel][3][1] = ijel[iel][3][0];
ncon_edge[sje[ntemp][0][0][0]][5] = true;
if_1_edge[iel][3] = true;
}
if (cbc[ntemp][0] == 3 && sje[ntemp][0][0][0] > iel) {
diagn[iel][3][0] = sje[ntemp][0][1][ijel[iel][3][0]];
}
}
}
if (cb5 == 2) {
if (ijel[iel][3][0] == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][11] = true;
} else {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][4] != 3 || sje[ntemp][4][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][11] = true;
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] > iel) {
diagn[iel][11][0] = sje[ntemp][4][ijel[iel][3][1]][1];
}
}
}
} else if (cb5 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][11] = true;
} else if (cb5 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][4] != 3 || sje[ntemp][4][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][11] = true;
if (cbc[ntemp][4] == 2) {
diagn[iel][11][0] = sje[ntemp][4][0][0];
diagn[iel][11][1] = ijel[iel][3][1];
ncon_edge[sje[ntemp][4][0][0]][8] = true;
if_1_edge[iel][11] = true;
}
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] > iel) {
diagn[iel][11][0] = sje[ntemp][4][ijel[iel][3][1]][1];
}
}
}
if (cb2 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][7] = true;
} else if (cb2 == 1) {
ntemp = sje[iel][3][0][0];
if (cbc[ntemp][1] != 3 || sje[ntemp][1][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][7] = true;
if (cbc[ntemp][1] == 2) {
diagn[iel][7][0] = sje[ntemp][1][0][0];
diagn[iel][7][1] = ijel[iel][3][0];
ncon_edge[sje[ntemp][1][0][0]][1] = true;
if_1_edge[iel][7] = true;
}
if (cbc[ntemp][1] == 3 && sje[ntemp][1][0][0] > iel) {
diagn[iel][7][0] = sje[ntemp][2][1][ijel[iel][3][0]];
}
}
}
}
// on face 2
if (cb2 == 0) {
if (cb3 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][5] = true;
}
if (cb5 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][6] = true;
}
} else if (cb2 == 1) {
if (cb3 == 2) {
if (ijel[iel][1][1] == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][5] = true;
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][2] != 3 || sje[ntemp][2][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][5] = true;
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] > iel) {
diagn[iel][5][0] = sje[ntemp][2][1][ijel[iel][1][0]];
}
}
}
} else if (cb3 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][5] = true;
} else if (cb3 == 1) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][2] != 3 || sje[ntemp][2][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][5] = true;
if (cbc[ntemp][2] == 2) {
diagn[iel][5][0] = sje[ntemp][2][0][0];
diagn[iel][5][1] = ijel[iel][1][0];
ncon_edge[sje[ntemp][2][0][0]][3] = true;
if_1_edge[iel][5] = true;
}
if (cbc[ntemp][2] == 3 && sje[ntemp][2][0][0] > iel) {
diagn[iel][5][0] = sje[ntemp][2][1][ijel[iel][3][0]];
}
}
}
if (cb5 == 2) {
if (ijel[iel][1][0] == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][6] = true;
} else {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][4] != 3 || sje[ntemp][4][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][6] = true;
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] > iel) {
diagn[iel][6][0] = sje[ntemp][4][1][ijel[iel][1][1]];
}
}
}
} else if (cb5 == 0) {
newe[iel] = newe[iel]+1;
eassign[iel][6] = true;
} else if (cb5 == 1) {
ntemp = sje[iel][1][0][0];
if (cbc[ntemp][4] != 3 || sje[ntemp][4][0][0] > iel) {
newe[iel] = newe[iel]+1;
eassign[iel][6] = true;
if (cbc[ntemp][4] == 2) {
diagn[iel][6][0] = sje[ntemp][4][0][0];
diagn[iel][6][1] = ijel[iel][1][1];
ncon_edge[sje[ntemp][4][0][0]][0] = true;
if_1_edge[iel][6] = true;
}
if (cbc[ntemp][4] == 3 && sje[ntemp][4][0][0] > iel) {
diagn[iel][6][0] = sje[ntemp][4][ijel[iel][3][1]][1];
}
}
}
}
// on face 1
if (cb1 == 1) {
newe[iel] = newe[iel]+2;
eassign[iel][1] = true;
if (cb3 == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][2] == 2) {
diagn[iel][1][0] = sje[ntemp][2][0][0];
diagn[iel][1][1] = ijel[iel][0][0];
ncon_edge[sje[ntemp][2][0][0]][7] = true;
if_1_edge[iel][1] = true;
} else if (cbc[ntemp][2] == 3) {
diagn[iel][1][0] = sje[ntemp][2][0][ijel[iel][0][0]];
}
} else if (cb3 == 2) {
ntemp = sje[iel][2][0][0];
if (ijel[iel][0][1] == 1) {
if (cbc[ntemp][0] == 2) {
diagn[iel][1][0] = sje[ntemp][0][0][0];
}
}
}
eassign[iel][2] = true;
if (cb5 == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][4] == 2) {
diagn[iel][2][0] = sje[ntemp][4][0][0];
diagn[iel][2][1] = ijel[iel][0][1];
ncon_edge[sje[ntemp][4][0][0]][4] = true;
if_1_edge[iel][2] = true;
} else if (cbc[ntemp][4] == 3) {
diagn[iel][2][0] = sje[ntemp][4][0][ijel[iel][0][1]];
}
} else if (cb5 == 2) {
ntemp = sje[iel][4][0][0];
if (ijel[iel][0][0] == 1) {
if (cbc[ntemp][0] == 2) {
diagn[iel][2][0] = sje[ntemp][0][0][0];
}
}
}
} else if (cb1 == 2) {
if (cb3 == 2) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][2] != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][1] = true;
if (cbc[ntemp][2] == 2) {
diagn[iel][1][0] = sje[ntemp][2][0][0];
}
}
} else if (cb3 == 0 || cb3 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][1] = true;
if (cb3 == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][2] == 2) {
diagn[iel][1][0] = sje[ntemp][2][0][0];
}
}
}
if (cb5 == 2) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][4] != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][2] = true;
if (cbc[ntemp][4] == 2) {
diagn[iel][2][0] = sje[ntemp][4][0][0];
}
}
} else if (cb5 == 0 || cb5 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][2] = true;
if (cb5 == 1) {
ntemp = sje[iel][0][0][0];
if (cbc[ntemp][4] == 2) {
diagn[iel][2][0] = sje[ntemp][4][0][0];
}
}
}
} else if (cb1 == 0) {
if (cb3 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][1] = true;
}
if (cb5 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][2] = true;
}
}
// on face 3
if (cb3 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][9] = true;
if (cb5 == 1) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][4] == 2) {
diagn[iel][9][0] = sje[ntemp][4][0][0];
diagn[iel][9][1] = ijel[iel][2][1];
ncon_edge[sje[ntemp][4][0][0]][10] = true;
if_1_edge[iel][9] = true;
}
}
if (ijel[iel][2][0] == 1) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][4] == 3) {
diagn[iel][9][0] = sje[ntemp][4][ijel[iel][2][1]][0];
}
}
} else if (cb3 == 2) {
if (cb5 == 2) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][4] != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][9] = true;
if (cbc[ntemp][4] == 2) {
diagn[iel][9][0] = sje[ntemp][4][0][0];
}
}
} else if (cb5 == 0 || cb5 == 1) {
newe[iel] = newe[iel]+1;
eassign[iel][9] = true;
if (cb5 == 1) {
ntemp = sje[iel][2][0][0];
if (cbc[ntemp][4] == 2) {
diagn[iel][9][0] = sje[ntemp][4][0][0];
}
}
}
} else if (cb3 == 0) {
if (cb5 != 3) {
newe[iel] = newe[iel]+1;
eassign[iel][9] = true;
}
}
// CONFORMING FACE INTERIOR
// find how many new mortar point indices will be assigned
// to face interiors on all faces on each element
// newi record how many new face interior points will be assigned
// on face 6
if (cb6 == 1 || cb6 == 0) {
newi[iel] = newi[iel]+9;
fassign[iel][5] = true;
}
// on face 4
if (cb4 == 1 || cb4 == 0) {
newi[iel] = newi[iel]+9;
fassign[iel][3] = true;
}
// on face 2
if (cb2 == 1 || cb2 == 0) {
newi[iel] = newi[iel]+9;
fassign[iel][1] = true;
}
// on face 1
if (cb1 != 3) {
newi[iel] = newi[iel]+9;
fassign[iel][0] = true;
}
// on face 3
if (cb3 != 3) {
newi[iel] = newi[iel]+9;
fassign[iel][2] = true;
}
// on face 5
if (cb5 != 3) {
newi[iel] = newi[iel]+9;
fassign[iel][4] = true;
}
// newc is the total number of new mortar point indices
// to be assigned to each element.
newc[iel] = newe[iel]*3+newi[iel];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,cb1,cb2,cb3,cb4,cb5 \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel) | 100 | conforming face interiors) from element 0 to iel.
// front[iel]=newc[0]+newc[1]+...+newc[iel]
<LOOP-START>for (iel = 0; iel < nelt; iel++) {
front[iel] = newc[iel];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) private(iel,count,i,cb1,ne, \ | 100 | g element face. On each face, first visit all
// conforming edges, and then the face interior.
<LOOP-START>space,ie,edge_g,face2,ie2,ntemp,ii,jj,jface,cb,mor_v)
for (iel = 0; iel < nelt; iel++) {
front[iel] = front[iel]-newc[iel];
count = nvertex+front[iel];
for (i = 0; i < 6; i++) {
cb1 = cbc[iel][i];
if (i < 2) {
ne = 4;
space = 1;
} else if (i < 4) {
ne = 3;
space = 2;
// i loops over faces. Only 4 faces need to be examed for edge visit.
// On face 1, edge 0,1,2 and 3 will be visited. On face 2, edge 4,5,6
// and 7 will be visited. On face 3, edge 8 and 9 will be visited and
// on face 4, edge 10 and 11 will be visited. The 12 edges can be
// covered by four faces, there is no need to visit edges on face
// 5 and 6. So ne is set to be 0.
// However, i still needs to loop over 4 and 5, since the interiors
// of face 5 and 6 still need to be visited.
} else {
ne = 0;
space = 1;
}
for (ie = 0; ie < ne; ie += space) {
edge_g = edgenumber[i][ie];
if (eassign[iel][edge_g]) {
// generate the new mortar points index, mor_v
mor_assign(mor_v, &count);
// assign mor_v to local edge ie of face i on element iel
mor_edge(ie, i, iel, mor_v);
// Since this edge is shared by another face of element
// iel, assign mor_v to the corresponding edge on the other
// face also.
// find the other face
face2 = f_e_ef[i][ie];
// find the local edge index of this edge on the other face
ie2 = localedgenumber[edge_g][face2];
// asssign mor_v to local edge ie2 of face face2 on element iel
mor_edge(ie2, face2, iel, mor_v);
// There are some neighbor elements also sharing this edge. Assign
// mor_v to neighbor element, neighbored by face i.
if (cbc[iel][i] == 2) {
ntemp = sje[iel][i][0][0];
mor_edge(ie, jjface[i], ntemp, mor_v);
mor_edge(op[ie2], face2, ntemp, mor_v);
}
// assign mor_v to neighbor element neighbored by face face2
if (cbc[iel][face2] == 2) {
ntemp = sje[iel][face2][0][0];
mor_edge(ie2, jjface[face2], ntemp, mor_v);
mor_edge(op[ie], i, ntemp, mor_v);
}
// assign mor_v to neighbor element sharing this edge
// if the neighbor is of the same size of iel
if (!if_1_edge[iel][edgenumber[i][ie]]) {
if (diagn[iel][edgenumber[i][ie]][0] != -1) {
ntemp = diagn[iel][edgenumber[i][ie]][0];
mor_edge(op[ie2], jjface[face2], ntemp, mor_v);
mor_edge(op[ie], jjface[i], ntemp, mor_v);
}
// if the neighbor has a size larger than iel's
} else {
if (diagn[iel][edgenumber[i][ie]][0] != -1) {
ntemp = diagn[iel][edgenumber[i][ie]][0];
mor_ne(mor_v, diagn[iel][edgenumber[i][ie]][1],
ie, i, ie2, face2, iel, ntemp);
}
}
}
}
if (fassign[iel][i]) {
// generate new mortar points index in face interior.
// if face i is of type 2 or iel doesn't have a neighbor element,
// assign new mortar point indices to interior mortar points
// of face i of iel.
cb = cbc[iel][i];
if (cb == 1 || cb == 0) {
for (jj = 1; jj < LX1-1; jj++) {
for (ii = 1; ii < LX1-1; ii++) {
idmo[iel][i][0][0][jj][ii] = count;
count = count+1;
}
}
// if face i is of type 2, assign new mortar point indices
// to iel as well as to the neighboring element on face i
} else if (cb == 2) {
if (idmo[iel][i][0][0][1][1] == -1) {
ntemp = sje[iel][i][0][0];
jface = jjface[i];
for (jj = 1; jj < LX1-1; jj++) {
for (ii = 1; ii < LX1-1; ii++) {
idmo[iel][i][0][0][jj][ii] = count;
idmo[ntemp][jface][0][0][jj][ii] = count;
count = count+1;
}
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,count,i,cb1,ne, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/mason.c | #pragma omp parallel for default(shared) \ | 100 | }
}
// for edges on nonconforming faces, copy the mortar points indices
// from neighbors.
<LOOP-START>private(iel,i,cb,jface,iii,jjj,ntemp,ii,jj)
for (iel = 0; iel < nelt; iel++) {
for (i = 0; i < 6; i++) {
cb = cbc[iel][i];
if (cb == 3) {
// edges
edgecopy_s(i, iel);
}
// face interior
jface = jjface[i];
if (cb == 3) {
for (iii = 0; iii < 2; iii++) {
for (jjj = 0; jjj < 2; jjj++) {
ntemp = sje[iel][i][jjj][iii];
for (jj = 0; jj < LX1; jj++) {
for (ii = 0; ii < LX1; ii++) {
idmo[iel][i][jjj][iii][jj][ii] =
idmo[ntemp][jface][0][0][jj][ii];
}
}
idmo[iel][i][jjj][iii][0][0] = idmo[ntemp][jface][0][0][0][0];
idmo[iel][i][jjj][iii][0][LX1-1] = idmo[ntemp][jface][1][0][0][LX1-1];
idmo[iel][i][jjj][iii][LX1-1][0] = idmo[ntemp][jface][0][1][LX1-1][0];
idmo[iel][i][jjj][iii][LX1-1][LX1-1]=
idmo[ntemp][jface][1][1][LX1-1][LX1-1];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(iel) | 100 | rsen = 0;
// skip[iel]=true indicates an element no longer exists (because it
// got merged)
<LOOP-START>for (iel = 0; iel < nelt; iel++) {
skip[iel] = false;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel,iel) | 100 | iel) takes as argument the actual element index and returns the
// morton index
<LOOP-START>for (miel = 0; miel < nelt; miel++) {
iel = mt_to_id[miel];
id_to_mt[iel] = miel;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel,iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel,iel,ic, \ | 100 | potential coarsening will make neighbor,
// and neighbor's neighbor....break grid restriction
<LOOP-START>ntp,parent,test,test1,i,test2,test3) shared(if_coarsen)
for (miel = 0; miel < nelt; miel++) {
ifcoa[miel] = false;
front[miel] = 0;
iel = mt_to_id_old[miel];
// if an element is marked to be coarsened
if (ich[iel] == 2) {
// If the current element is the "first" child (front-left-
// bottom) of its parent (tree[iel] mod 8 equals 0), then
// find all its neighbors. Check whether they are from the same
// parent.
ic = tree[iel];
if (!btest(ic,0) && !btest(ic,1) && !btest(ic,2)) {
ntp[0] = iel;
ntp[1] = sje[iel][0][0][0];
ntp[2] = sje[iel][2][0][0];
ntp[3] = sje[ntp[2]][0][0][0];
ntp[4] = sje[iel][4][0][0];
ntp[5] = sje[ntp[4]][0][0][0];
ntp[6] = sje[ntp[4]][2][0][0];
ntp[7] = sje[ntp[6]][0][0][0];
parent = tree[iel] >> 3;
test = false;
test1 = true;
for (i = 0; i < 8; i++) {
if ((tree[ntp[i]] >> 3) != parent) test1 = false;
}
// check whether all child elements are marked to be coarsened
if (test1) {
test2 = true;
for (i = 0; i < 8; i++) {
if (ich[ntp[i]] != 2) test2 = false;
}
// check whether all child elements can be coarsened or not.
if (test2) {
test3 = true;
for (i = 0; i < 8; i++) {
if (!icheck(ntp[i],i)) test3 = false;
}
if (test3) test = true;
}
}
// if the eight child elements are eligible to be coarsened
// mark the first children ifcoa[miel]=true
// mark them all ifcoa_id[]=true
// front[miel] will be used to calculate (potentially in parallel)
// how many elements with seuqnece numbers less than
// miel will be coarsened.
// skip[] marks that an element will no longer exist after merge.
if (test) {
ifcoa[miel] = true;
for (i = 0; i < 8; i++) {
ifcoa_id[ntp[i]] = true;
}
front[miel] = 1;
for (i = 0; i < 7; i++) {
skip[ntp[i+1]] = true;
}
if (!(*if_coarsen)) *if_coarsen = true;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel,iel,ic, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel,iel,mielnew) | 100 | ild) to be coarsened.
// create array mt_to_id to convert actual element index to morton index
<LOOP-START>for (miel = 0; miel < nelt; miel++) {
iel = mt_to_id_old[miel];
if (!skip[iel]) {
if (ifcoa[miel]) {
action[front[miel]-1] = miel;
mielnew = miel-(front[miel]-1)*7;
} else {
mielnew = miel-front[miel]*7;
}
mt_to_id[mielnew] = iel;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel,iel,mielnew)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(index,miel,iel,ntp) | 100 | _to_id[mielnew] = iel;
}
}
// perform the coarsening procedure (potentially in parallel)
<LOOP-START>for (index = 0; index < num_coarsen; index++) {
miel = action[index];
iel = mt_to_id_old[miel];
// find eight child elements to be coarsened
ntp[0] = iel;
ntp[1] = sje[iel][0][0][0];
ntp[2] = sje[iel][2][0][0];
ntp[3] = sje[ntp[2]][0][0][0];
ntp[4] = sje[iel][4][0][0];
ntp[5] = sje[ntp[4]][0][0][0];
ntp[6] = sje[ntp[4]][2][0][0];
ntp[7] = sje[ntp[6]][0][0][0];
// merge them to be the parent
merging(ntp);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(index,miel,iel,ntp)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel) | 100 | index, treetemp;
int sjetemp[6][2][2], n1, n2, nelttemp;
int cb, cbctemp[6];
// initialize
<LOOP-START>for (miel = 0; miel < nelt; miel++) {
mt_to_id_old[miel] = mt_to_id[miel];
mt_to_id[miel] = -1;
action[miel] = -1;
if (ich[mt_to_id_old[miel]] != 4) {
front[miel] = 0;
} else {
front[miel] = 1;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel,iel) | 100 | fine = front[nelt-1];
// action[i] records the morton index of the i'th element to be refined
<LOOP-START>for (miel = 0; miel < nelt; miel++) {
iel = mt_to_id_old[miel];
if (ich[iel] == 4) {
action[front[miel]-1] = miel;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel,iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(miel,iel,ntemp,mielnew) | 100 | elements with index less than
// iel (actual element index, not morton index), will be refined.
<LOOP-START>for (miel = 0; miel < nelt; miel++) {
iel = mt_to_id_old[miel];
if (ich[iel] == 4) {
ntemp = (front[miel]-1)*7;
mielnew = miel+ntemp;
} else {
ntemp = front[miel]*7;
mielnew = miel+ntemp;
}
mt_to_id[mielnew] = iel;
ref_front_id[iel] = nelt+ntemp;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(miel,iel,ntemp,mielnew)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(index,miel,mielnew,iel, \ | 100 | neighboring information.
nelttemp = nelt;
if (num_refine > 0) {
*ifmortar = true;
}
<LOOP-START>nelt,treetemp,xctemp,yctemp,zctemp,cbctemp,sjetemp,ta1temp, \
ii,jj,ntemp,xleft,xright,xhalf,yleft,yright,yhalf,zleft,zright,\
zhalf,ndir,facedir,jface,cb,le,ne,n1,n2,i,j,k)
for (index = 0; index < num_refine; index++) {
// miel is old morton index and mielnew is new morton index after refinement.
miel = action[index];
mielnew = miel+(front[miel]-1)*7;
iel = mt_to_id_old[miel];
nelt = nelttemp+(front[miel]-1)*7;
// save iel's information in a temporary array
treetemp = tree[iel];
for (i = 0; i < 8; i++) {
xctemp[i] = xc[iel][i];
yctemp[i] = yc[iel][i];
zctemp[i] = zc[iel][i];
}
for (i = 0; i < 6; i++) {
cbctemp[i] = cbc[iel][i];
for (jj = 0; jj < 2; jj++) {
for (ii = 0; ii < 2; ii++) {
sjetemp[i][jj][ii] = sje[iel][i][jj][ii];
}
}
}
copy((double *)ta1temp, ta1[iel][0][0], NXYZ);
// zero out iel here
tree[iel] = 0;
nr_init(cbc[iel], 6, 0);
nr_init(sje[iel][0][0], 24, -1);
nr_init(ijel[iel][0], 12, -1);
r_init(ta1[iel][0][0], NXYZ, 0.0);
// initialize new child elements:iel and nelt+1~nelt+7
for (j = 0; j < 7; j++) {
mt_to_id[mielnew+j+1] = nelt+j;
tree[nelt+j] = 0;
nr_init(cbc[nelt+j], 6, 0);
nr_init(sje[nelt+j][0][0], 24, -1);
nr_init(ijel[nelt+j][0], 12, -1);
r_init(ta1[nelt+j][0][0], NXYZ, 0.0);
}
// update the tree[]
ntemp = treetemp << 3;
tree[iel] = ntemp;
for (i = 0; i < 7; i++) {
tree[nelt+i] = ntemp + ((i + 1) % 8);
}
// update the children's vertices' coordinates
xhalf = xctemp[0]+(xctemp[1]-xctemp[0])/2.0;
xleft = xctemp[0];
xright = xctemp[1];
yhalf = yctemp[0]+(yctemp[2]-yctemp[0])/2.0;
yleft = yctemp[0];
yright = yctemp[2];
zhalf = zctemp[0]+(zctemp[4]-zctemp[0])/2.0;
zleft = zctemp[0];
zright = zctemp[4];
for (j = 0; j < 7; j += 2) {
for (i = 0; i < 7; i += 2) {
xc[nelt+j][i] = xhalf;
xc[nelt+j][i+1] = xright;
}
}
for (j = 1; j < 6; j += 2) {
for (i = 0; i < 7; i += 2) {
xc[nelt+j][i] = xleft;
xc[nelt+j][i+1] = xhalf;
}
}
for (i = 0; i < 7; i += 2) {
xc[iel][i] = xleft;
xc[iel][i+1] = xhalf;
}
for (i = 0; i < 2; i++) {
yc[nelt+0][i] = yleft;
yc[nelt+3][i] = yleft;
yc[nelt+4][i] = yleft;
yc[nelt+0][i+4] = yleft;
yc[nelt+3][i+4] = yleft;
yc[nelt+4][i+4] = yleft;
}
for (i = 2; i < 4; i++) {
yc[nelt+0][i] = yhalf;
yc[nelt+3][i] = yhalf;
yc[nelt+4][i] = yhalf;
yc[nelt+0][i+4] = yhalf;
yc[nelt+3][i+4] = yhalf;
yc[nelt+4][i+4] = yhalf;
}
for (j = 1; j < 3; j++) {
for (i = 0; i < 2; i++) {
yc[nelt+j][i] = yhalf;
yc[nelt+j+4][i] = yhalf;
yc[nelt+j][i+4] = yhalf;
yc[nelt+j+4][i+4] = yhalf;
}
for (i = 2; i < 4; i++) {
yc[nelt+j][i] = yright;
yc[nelt+j+4][i] = yright;
yc[nelt+j][i+4] = yright;
yc[nelt+j+4][i+4] = yright;
}
}
for (i = 0; i < 2; i++) {
yc[iel][i] = yleft;
yc[iel][i+4] = yleft;
}
for (i = 2; i < 4; i++) {
yc[iel][i] = yhalf;
yc[iel][i+4] = yhalf;
}
for (j = 0; j < 3; j++) {
for (i = 0; i < 4; i++) {
zc[nelt+j][i] = zleft;
zc[nelt+j][i+4] = zhalf;
}
}
for (j = 3; j < 7; j++) {
for (i = 0; i < 4; i++) {
zc[nelt+j][i] = zhalf;
zc[nelt+j][i+4] = zright;
}
}
for (i = 0; i < 4; i++) {
zc[iel][i] = zleft;
zc[iel][i+4] = zhalf;
}
// update the children's neighbor information
// ndir refers to the x,y,z directions, respectively.
// facedir refers to the orientation of the face in each direction,
// e.g. ndir=0, facedir=0 refers to face 1,
// and ndir =0, facedir=1 refers to face 2.
for (ndir = 0; ndir < 3; ndir++) {
for (facedir = 0; facedir <= 1; facedir++) {
i = 2*ndir+facedir;
jface = jjface[i];
cb = cbctemp[i];
// find the new element indices of the four children on each
// face of the parent element
for (k = 0; k < 4; k++) {
le[k] = le_arr[ndir][facedir][k]+nelt;
ne[k] = le_arr[ndir][1-facedir][k]+nelt;
}
if (facedir == 0) {
le[0] = iel;
} else {
ne[0] = iel;
}
// update neighbor information of the four child elements on each
// face of the parent element
for (k = 0; k < 4; k++) {
cbc[le[k]][i] = 2;
sje[le[k]][i][0][0] = ne[k];
ijel[le[k]][i][0] = 0;
ijel[le[k]][i][1] = 0;
}
// if the face type of the parent element is type 2
if (cb == 2 ) {
ntemp = sjetemp[i][0][0];
// if the neighbor ntemp is not marked to be refined
if (ich[ntemp] != 4) {
cbc[ntemp][jface] = 3;
ijel[ntemp][jface][0] = 0;
ijel[ntemp][jface][1] = 0;
for (k = 0; k < 4; k++) {
cbc[ne[k]][i] = 1;
sje[ne[k]][i][0][0] = ntemp;
if (k == 0) {
ijel[ne[k]][i][0] = 0;
ijel[ne[k]][i][1] = 0;
sje[ntemp][jface][0][0] = ne[k];
} else if (k == 1) {
ijel[ne[k]][i][0] = 0;
ijel[ne[k]][i][1] = 1;
sje[ntemp][jface][1][0] = ne[k];
} else if (k == 2) {
ijel[ne[k]][i][0] = 1;
ijel[ne[k]][i][1] = 0;
sje[ntemp][jface][0][1] = ne[k];
} else if (k == 3) {
ijel[ne[k]][i][0] = 1;
ijel[ne[k]][i][1] = 1;
sje[ntemp][jface][1][1] = ne[k];
}
}
// if the neighbor ntemp is also marked to be refined
} else {
n1 = ref_front_id[ntemp];
for (k = 0; k < 4; k++) {
cbc[ne[k]][i] = 2;
n2 = n1 + le_arr[ndir][facedir][k];
if (n2 == n1+7) n2 = ntemp;
sje[ne[k]][i][0][0] = n2;
ijel[ne[k]][i][0] = 0;
}
}
// if the face type of the parent element is type 3
} else if (cb == 3) {
for (k = 0; k < 4; k++) {
cbc[ne[k]][i] = 2;
if (k == 0) {
ntemp = sjetemp[i][0][0];
} else if (k == 1) {
ntemp = sjetemp[i][1][0];
} else if (k == 2) {
ntemp = sjetemp[i][0][1];
} else if (k == 3) {
ntemp = sjetemp[i][1][1];
}
ijel[ne[k]][i][0] = 0;
ijel[ne[k]][i][1] = 0;
sje[ne[k]][i][0][0] = ntemp;
cbc[ntemp][jface] = 2;
sje[ntemp][jface][0][0] = ne[k];
ijel[ntemp][jface][0] = 0;
ijel[ntemp][jface][1] = 0;
}
// if the face type of the parent element is type 0
} else if (cb == 0) {
for (k = 0; k < 4; k++) {
cbc[ne[k]][i] = cb;
}
}
}
}
// map solution from parent element to children
remap(ta1[iel], &ta1[ref_front_id[iel]], ta1temp);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(index,miel,mielnew,iel, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(iel,i,iftemp) \ | 100 | rsen(logical *if_coarsen, int neltold)
{
logical iftemp;
int iel, i;
*if_coarsen = false;
<LOOP-START>shared(if_coarsen)
for (iel = 0; iel < neltold; iel++) {
if (!skip[iel]) {
ich[iel] = 0;
if (!iftouch(iel)) {
iftemp = false;
for (i = 0; i < NSIDES; i++) {
// if iel has a larger size than its face neighbors, it
// can not be coarsened
if (cbc[iel][i] == 3) {
iftemp = true;
}
}
if(!iftemp) {
if (!(*if_coarsen)) *if_coarsen = true;
ich[iel] = 2;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,i,iftemp) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(iel) shared(if_refine) | 100 | ----------------
static void find_refine(logical *if_refine)
{
int iel;
*if_refine = false;
<LOOP-START>for (iel = 0; iel < nelt; iel++) {
ich[iel] = 0;
if (iftouch(iel)) {
if ((xc[iel][1] - xc[iel][0]) > dlmin) {
if (!(*if_refine)) *if_refine = true;
ich[iel] = 4;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel) shared(if_refine)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/adapt.c | #pragma omp parallel for default(shared) private(iel,i,jface,ntemp, \ | 100 | eck_refine(logical *ifrepeat)
{
int iel, iface, ntemp, nntemp, i, jface;
*ifrepeat = false;
<LOOP-START>iface,nntemp) shared(ifrepeat)
for (iel = 0; iel < nelt; iel++) {
// if iel is marked to be refined
if (ich[iel] == 4) {
// check its six faces
for (i = 0; i < NSIDES; i++) {
jface = jjface[i];
ntemp = sje[iel][i][0][0];
// if one face neighbor is larger in size than iel
if (cbc[iel][i] == 1) {
// unmark iel
ich[iel] = 0;
// the large size neighbor ntemp is marked to be refined
if (ich[ntemp] != 4) {
if (!(*ifrepeat)) *ifrepeat = true;
ich[ntemp] = 4;
}
// check iel's neighbor, neighbored by an edge on face i, which
// must be a face neighbor of ntemp
for (iface = 0; iface < NSIDES; iface++) {
if (iface != i && iface != jface) {
//if edge neighbors are larger than iel, mark them to be refined
if (cbc[ntemp][iface] == 2) {
nntemp = sje[ntemp][iface][0][0];
// ifcor is to make sure the edge neighbor exist
if (ich[nntemp] !=4 && ifcor(iel, nntemp, i, iface)) {
ich[nntemp] = 4;
}
}
}
}
//if face neighbor are of the same size of iel, check edge neighbors
} else if (cbc[iel][i] == 2) {
for (iface = 0; iface < NSIDES; iface++) {
if (iface != i && iface != jface) {
if (cbc[ntemp][iface] == 1) {
nntemp = sje[ntemp][iface][0][0];
ich[nntemp] = 4;
ich[iel] = 0;
if (!(*ifrepeat)) *ifrepeat = true;
}
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,i,jface,ntemp, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/diffuse.c | #pragma omp parallel for default(shared) private(i) | 100 | of (am pm) in the CG algorithm
// (see the specification)
r_init_omp((double *)t, ntot, 0.0);
<LOOP-START>for (i = 0; i < nmor; i++) {
umor[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/diffuse.c | #pragma omp parallel for default(shared) private(ie) | 100 | imeron) timer_stop(t_transf);
// compute pdiffp which is (A theta pm) in the specification
<LOOP-START>for (ie = 0; ie < nelt; ie++) {
laplacian(pdiffp[ie], pdiff[ie], size_e[ie]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ie) <OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/diffuse.c | #pragma omp parallel for default(shared) private(ie,iside) | 100 | or, (double *)pdiffp);
if (timeron) timer_stop(t_transfb);
// apply boundary condition
<LOOP-START>for (ie = 0; ie < nelt; ie++) {
for (iside = 0; iside < NSIDES; iside++) {
if(cbc[ie][iside] == 0) {
facev(pdiffp[ie], iside, 0.0);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ie,iside)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/precond.c | #pragma omp parallel for default(shared) private(ie,isize,i,j,k,q) | 100 | i < LX1; i++) {
dxtm1_2[j][i] = dxtm1[j][i]*dxtm1[j][i];
}
}
rdtime = 1.0/dtime;
<LOOP-START>for (ie = 0; ie < nelt; ie++) {
r_init(dpcelm[ie][0][0], NXYZ, 0.0);
isize = size_e[ie];
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
for (q = 0; q < LX1; q++) {
dpcelm[ie][k][j][i] = dpcelm[ie][k][j][i] +
g1m1_s[isize][k][j][q] * dxtm1_2[q][i] +
g1m1_s[isize][k][q][i] * dxtm1_2[q][j] +
g1m1_s[isize][q][j][i] * dxtm1_2[q][k];
}
dpcelm[ie][k][j][i] = VISC*dpcelm[ie][k][j][i]+
rdtime*bm1_s[isize][k][j][i];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ie,isize,i,j,k,q) <OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/precond.c | #pragma omp parallel for default(shared) private(i) | 100 | rtar points. NOTE: dpcmor for
// nonconforming cases will be corrected in subroutine setpcmo
<LOOP-START>for (i = 0; i < nmor; i++) {
dpcmor[i] = 1.0/dpcmor[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/precond.c | #pragma omp parallel for default(shared) private(element_size,i,j,p,temp, \ | 100 | ; i++) {
tcpre[j][col] = tcpre[j][col] + qbnew[0][i][j-1]*tmp[i][col];
}
}
}
<LOOP-START>mtemp,temp1,p0,ii,jj)
for (element_size = 0; element_size < REFINE_MAX; element_size++) {
// for conforming cases
// pcmor_c[element_size][j][i] records the intermediate value
// (preconditioner=1/pcmor_c) of the preconditor on collocation
// point (i,j) on a conforming face of an element of size
// element_size.
for (j = 0; j < LX1/2+1; j++) {
for (i = j; i < LX1/2+1; i++) {
r_init((double *)p, NXYZ, 0.0);
p[0][j][i] = 1.0;
laplacian(temp, p, element_size);
pcmor_c[element_size][j][i] = temp[0][j][i];
pcmor_c[element_size][j][LX1-1-i] = temp[0][j][i];
pcmor_c[element_size][i][j] = temp[0][j][i];
pcmor_c[element_size][i][LX1-1-j] = temp[0][j][i];
pcmor_c[element_size][LX1-1-i][j] = temp[0][j][i];
pcmor_c[element_size][LX1-1-i][LX1-1-j] = temp[0][j][i];
pcmor_c[element_size][LX1-1-j][i] = temp[0][j][i];
pcmor_c[element_size][LX1-1-j][LX1-1-i] = temp[0][j][i];
}
}
// for nonconforming cases
// nonconforming face interior
// pcmor_nc1[element_size][jj][ii][j][i] records the intermediate
// preconditioner value on collocation point (i,j) on mortar
// (ii,jj) on a nonconforming face of an element of size element_
// size
for (j = 1; j < LX1; j++) {
for (i = j; i < LX1; i++) {
r_init((double *)mtemp, LX1*LX1, 0.0);
r_init((double *)p, NXYZ, 0.0);
mtemp[j][i] = 1.0;
// when i, j=LX1-1, mortar points are duplicated, so mtemp needs
// to be doubled.
if (i == (LX1-1)) mtemp[j][i] = mtemp[j][i]*2.0;
if (j == (LX1-1)) mtemp[j][i] = mtemp[j][i]*2.0;
transf_nc(mtemp, (double (*)[LX1])p);
laplacian(temp, p, element_size);
transfb_nc1(temp1, (double (*)[LX1])temp);
// values at points (i,j) and (j,i) are the same
pcmor_nc1[element_size][0][0][j][i] = temp1[j][i];
pcmor_nc1[element_size][0][0][i][j] = temp1[j][i];
}
// when i, j=LX1-1, mortar points are duplicated. so pcmor_nc1 needs
// to be doubled on those points
pcmor_nc1[element_size][0][0][j][LX1-1]=
pcmor_nc1[element_size][0][0][j][LX1-1]*2.0;
pcmor_nc1[element_size][0][0][LX1-1][j]=
pcmor_nc1[element_size][0][0][j][LX1-1];
}
pcmor_nc1[element_size][0][0][LX1-1][LX1-1]=
pcmor_nc1[element_size][0][0][LX1-1][LX1-1]*2.0;
// nonconforming edges
j = 0;
for (i = 1; i < LX1; i++) {
r_init((double *)mtemp, LX1*LX1, 0.0);
r_init((double *)p, NXYZ, 0.0);
r_init((double *)p0, NXYZ, 0.0);
mtemp[j][i] = 1.0;
if (i == (LX1-1)) mtemp[j][i] = 2.0;
transf_nc(mtemp, (double (*)[LX1])p);
laplacian(temp, p, element_size);
transfb_nc1(temp1, (double (*)[LX1])temp);
pcmor_nc1[element_size][0][0][j][i] = temp1[j][i];
pcmor_nc1[element_size][0][0][i][j] = temp1[j][i];
for (ii = 0; ii < LX1; ii++) {
// p0 is for the case that a nonconforming edge is shared by
// two conforming faces
p0[0][0][ii] = p[0][0][ii];
for (jj = 0; jj < LX1; jj++) {
// now p is for the case that a nonconforming edge is shared
// by nonconforming faces
p[jj][0][ii] = p[0][jj][ii];
}
}
laplacian(temp, p, element_size);
transfb_nc2(temp1, (double (*)[LX1])temp);
// pcmor_nc2[element_size][jj][ii][j][i] gives the intermediate
// preconditioner value on collocation point (i,j) on a
// nonconforming face of an element with size size_element
pcmor_nc2[element_size][0][0][j][i] = temp1[j][i]*2.0 ;
pcmor_nc2[element_size][0][0][i][j] =
pcmor_nc2[element_size][0][0][j][i];
laplacian(temp, p0, element_size);
transfb_nc0(temp1, temp);
// pcmor_nc0[element_size][jj][ii][j][i] gives the intermediate
// preconditioner value on collocation point (i,j) on a
// conforming face of an element, which shares a nonconforming
// edge with another conforming face
pcmor_nc0[element_size][0][0][j][i] = temp1[j][i];
pcmor_nc0[element_size][0][0][i][j] = temp1[j][i];
}
pcmor_nc1[element_size][0][0][j][LX1-1] =
pcmor_nc1[element_size][0][0][j][LX1-1]*2.0;
pcmor_nc1[element_size][0][0][LX1-1][j] =
pcmor_nc1[element_size][0][0][j][LX1-1];
pcmor_nc2[element_size][0][0][j][LX1-1] =
pcmor_nc2[element_size][0][0][j][LX1-1]*2.0;
pcmor_nc2[element_size][0][0][LX1-1][j] =
pcmor_nc2[element_size][0][0][j][LX1-1];
pcmor_nc0[element_size][0][0][j][LX1-1] =
pcmor_nc0[element_size][0][0][j][LX1-1]*2.0;
pcmor_nc0[element_size][0][0][LX1-1][j] =
pcmor_nc0[element_size][0][0][j][LX1-1];
// symmetrical copy
for (i = 0; i < LX1-1; i++) {
pcmor_nc1[element_size][1][0][j][i] =
pcmor_nc1[element_size][0][0][j][LX1-1-i];
pcmor_nc0[element_size][1][0][j][i] =
pcmor_nc0[element_size][0][0][j][LX1-1-i];
pcmor_nc2[element_size][1][0][j][i] =
pcmor_nc2[element_size][0][0][j][LX1-1-i];
}
for (j = 1; j < LX1; j++) {
for (i = 0; i < LX1-1; i++) {
pcmor_nc1[element_size][1][0][j][i] =
pcmor_nc1[element_size][0][0][j][LX1-1-i];
}
i = LX1-1;
pcmor_nc1[element_size][1][0][j][i] =
pcmor_nc1[element_size][0][0][j][LX1-1-i];
pcmor_nc0[element_size][1][0][j][i] =
pcmor_nc0[element_size][0][0][j][LX1-1-i];
pcmor_nc2[element_size][1][0][j][i] =
pcmor_nc2[element_size][0][0][j][LX1-1-i];
}
j = 0;
i = 0;
pcmor_nc1[element_size][0][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][i];
pcmor_nc0[element_size][0][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][i];
pcmor_nc2[element_size][0][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][i];
for (j = 1; j < LX1-1; j++) {
i = 0;
pcmor_nc1[element_size][0][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][i];
pcmor_nc0[element_size][0][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][i];
pcmor_nc2[element_size][0][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][i];
for (i = 1; i < LX1; i++) {
pcmor_nc1[element_size][0][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][i];
}
}
j = LX1-1;
for (i = 1; i < LX1; i++) {
pcmor_nc1[element_size][0][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][i];
pcmor_nc0[element_size][0][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][i];
pcmor_nc2[element_size][0][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][i];
}
j = 0;
i = LX1-1;
pcmor_nc1[element_size][1][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc0[element_size][1][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc2[element_size][1][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][LX1-1-i];
for (j = 1; j < LX1-1; j++) {
for (i = 1; i < LX1-1; i++) {
pcmor_nc1[element_size][1][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][LX1-1-i];
}
i = LX1-1;
pcmor_nc1[element_size][1][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc0[element_size][1][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc2[element_size][1][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][LX1-1-i];
}
j = LX1-1;
for (i = 1; i < LX1-1; i++) {
pcmor_nc1[element_size][1][1][j][i] =
pcmor_nc1[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc0[element_size][1][1][j][i] =
pcmor_nc0[element_size][0][0][LX1-1-j][LX1-1-i];
pcmor_nc2[element_size][1][1][j][i] =
pcmor_nc2[element_size][0][0][LX1-1-j][LX1-1-i];
}
// vertices shared by at least one nonconforming face or edge
// Among three edges and three faces sharing a vertex on an element
// situation 1: only one edge is nonconforming
// situation 2: two edges are nonconforming
// situation 3: three edges are nonconforming
// situation 4: one face is nonconforming
// situation 5: one face and one edge are nonconforming
// situation 6: two faces are nonconforming
// situation 7: three faces are nonconforming
r_init((double *)p0, NXYZ, 0.0);
p0[0][0][0] = 1.0;
laplacian(temp, p0, element_size);
pcmor_cor[element_size][7] = temp[0][0][0];
// situation 1
r_init((double *)p0, NXYZ, 0.0);
for (i = 0; i < LX1; i++) {
p0[0][0][i] = tcpre[0][i];
}
laplacian(temp, p0, element_size);
transfb_cor_e(1, &pcmor_cor[element_size][0], temp);
// situation 2
r_init((double *)p0, NXYZ, 0.0);
for (i = 0; i < LX1; i++) {
p0[0][0][i] = tcpre[0][i];
p0[0][i][0] = tcpre[0][i];
}
laplacian(temp, p0, element_size);
transfb_cor_e(2, &pcmor_cor[element_size][1], temp);
// situation 3
r_init((double *)p0, NXYZ, 0.0);
for (i = 0; i < LX1; i++) {
p0[0][0][i] = tcpre[0][i];
p0[0][i][0] = tcpre[0][i];
p0[i][0][0] = tcpre[0][i];
}
laplacian(temp, p0, element_size);
transfb_cor_e(3, &pcmor_cor[element_size][2], temp);
// situation 4
r_init((double *)p0, NXYZ, 0.0);
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
p0[0][j][i] = tcpre[j][i];
}
}
laplacian(temp, p0, element_size);
transfb_cor_f(4, &pcmor_cor[element_size][3], temp);
// situation 5
r_init((double *)p0, NXYZ, 0.0);
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
p0[0][j][i] = tcpre[j][i];
}
}
for (i = 0; i < LX1; i++) {
p0[i][0][0] = tcpre[0][i];
}
laplacian(temp, p0, element_size);
transfb_cor_f(5, &pcmor_cor[element_size][4], temp);
// situation 6
r_init((double *)p0, NXYZ, 0.0);
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
p0[0][j][i] = tcpre[j][i];
p0[j][0][i] = tcpre[j][i];
}
}
laplacian(temp, p0, element_size);
transfb_cor_f(6, &pcmor_cor[element_size][5], temp);
// situation 7
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
p0[0][j][i] = tcpre[j][i];
p0[j][0][i] = tcpre[j][i];
p0[j][i][0] = tcpre[j][i];
}
}
laplacian(temp, p0, element_size);
transfb_cor_f(7, &pcmor_cor[element_size][6], temp);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(element_size,i,j,p,temp, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/precond.c | #pragma omp parallel for default(shared) private(iel,iside,sizei, \ | 100 | ; i++) {
edgevis[iel][iside][i] = false;
}
}
}
} //end parallel
<LOOP-START>imor,_enum,face2,nb1,nb2,i,j,nn1,nn2)
for (iel = 0; iel < nelt; iel++) {
for (iside = 0; iside < NSIDES; iside++) {
// for nonconforming faces
if (cbc[iel][iside] == 3) {
sizei = size_e[iel];
// vertices
// ifpcmor[imor] = true indicates that mortar point imor has
// been visited
imor = idmo[iel][iside][0][0][0][0];
if (!ifpcmor[imor]) {
// compute the preconditioner on mortar point imor
pc_corner(imor);
ifpcmor[imor] = true;
}
imor = idmo[iel][iside][1][0][0][LX1-1];
if (!ifpcmor[imor]) {
pc_corner(imor);
ifpcmor[imor] = true;
}
imor = idmo[iel][iside][0][1][LX1-1][0];
if (!ifpcmor[imor]) {
pc_corner(imor);
ifpcmor[imor] = true;
}
imor = idmo[iel][iside][1][1][LX1-1][LX1-1];
if (!ifpcmor[imor]) {
pc_corner(imor);
ifpcmor[imor] = true;
}
// edges on nonconforming faces, _enum is local edge number
for (_enum = 0; _enum < 4; _enum++) {
// edgevis[iel][iside][_enum]=true indicates that local edge
// _enum of face iside of iel has been visited
if (!edgevis[iel][iside][_enum]) {
edgevis[iel][iside][_enum] = true;
// Examing neighbor element information,
// calculateing the preconditioner value.
face2 = f_e_ef[iside][_enum];
if (cbc[iel][face2] == 2) {
nb1 = sje[iel][face2][0][0];
if (cbc[nb1][iside] == 2) {
// Compute the preconditioner on local edge _enum on face
// iside of element iel, 1 is neighborhood information got
// by examing neighbors(nb1). For detailed meaning of 1,
// see subroutine com_dpc.
com_dpc(iside, iel, _enum, 1, sizei);
nb2 = sje[nb1][iside][0][0];
edgevis[nb2][jjface[face2]][op[e_face2[iside][_enum]]] = true;
} else if (cbc[nb1][iside] == 3) {
com_dpc(iside, iel, _enum, 2, sizei);
edgevis[nb1][iside][op[_enum]] = true;
}
} else if (cbc[iel][face2] == 3) {
edgevis[iel][face2][e_face2[iside][_enum]] = true;
nb1 = sje[iel][face2][1][0];
if (cbc[nb1][iside] == 1) {
com_dpc(iside, iel, _enum, 3, sizei);
nb2 = sje[nb1][iside][0][0];
edgevis[nb2][jjface[iside]][op[_enum]] = true;
edgevis[nb2][jjface[face2]][op[e_face2[iside][_enum]]] = true;
} else if (cbc[nb1][iside] == 2) {
com_dpc(iside, iel, _enum, 4, sizei);
}
} else if (cbc[iel][face2] == 0) {
com_dpc(iside, iel, _enum, 0, sizei);
}
}
}
// mortar element interior (not edge of mortar)
for (nn1 = 0; nn1 < 2; nn1++) {
for (nn2 = 0; nn2 < 2; nn2++) {
for (j = 1; j < LX1-1; j++) {
for (i = 1; i < LX1-1; i++) {
imor = idmo[iel][iside][nn2][nn1][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][nn2][nn1][j][i]+
pcmor_c[sizei+1][j][i]);
}
}
}
}
// for i,j=LX1-1 there are duplicated mortar points, so
// pcmor_c needs to be doubled or quadrupled
i = LX1-1;
for (j = 1; j < LX1-1; j++) {
imor = idmo[iel][iside][0][0][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][0][0][j][i]+
pcmor_c[sizei+1][j][i]*2.0);
imor = idmo[iel][iside][0][1][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][0][1][j][i]+
pcmor_c[sizei+1][j][i]*2.0);
}
j = LX1-1;
imor = idmo[iel][iside][0][0][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][0][0][j][i]+
pcmor_c[sizei+1][j][i]*4.0);
for (i = 1; i < LX1-1; i++) {
imor = idmo[iel][iside][0][0][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][0][0][j][i]+
pcmor_c[sizei+1][j][i]*2.0);
imor = idmo[iel][iside][1][0][j][i];
dpcmor[imor] = 1.0/(pcmor_nc1[sizei][1][0][j][i]+
pcmor_c[sizei+1][j][i]*2.0);
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(iel,iside,sizei, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/convect.c | #pragma omp parallel for default(shared) private(rk4,rk3,rk2,temp,rk1,dtx3,\ | 100 |
yy0[substep] = Y00+VELY*subtime[substep];
zz0[substep] = Z00+VELZ*subtime[substep];
}
<LOOP-START>dtx2,dtx1,iside,ip,sum,src,r2,i,j,k,isize,iel,tempa,xloc,yloc,zloc)
for (iel = 0; iel < nelt; iel++) {
isize = size_e[iel];
/*
xloc[i] is the location of i'th collocation in x direction in an element.
yloc[i] is the location of j'th collocation in y direction in an element.
zloc[i] is the location of k'th collocation in z direction in an element.
*/
for (i = 0; i < LX1; i++) {
xloc[i] = xfrac[i]*(xc[iel][1]-xc[iel][0])+xc[iel][0];
}
for (j = 0; j < LX1; j++) {
yloc[j] = xfrac[j]*(yc[iel][3]-yc[iel][0])+yc[iel][0];
}
for (k = 0; k < LX1; k++) {
zloc[k] = xfrac[k]*(zc[iel][4]-zc[iel][0])+zc[iel][0];
}
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
r2 = pow(xloc[i]-xx0[0],2.0)+pow(yloc[j]-yy0[0],2.0)+
pow(zloc[k]-zz0[0],2.0);
if (r2 <= alpha2) {
src = cos(sqrt(r2)*pidivalpha)+1.0;
} else {
src = 0.0;
}
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][i] * ta1[iel][k][j][ip];
}
dtx1 = -VELX*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][j] * ta1[iel][k][ip][i];
}
dtx2 = -VELY*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][k] * ta1[iel][ip][j][i];
}
dtx3 = -VELZ*sum*xrm1_s[isize][k][j][i];
rk1[k][j][i] = dtx1 + dtx2 + dtx3 + src;
temp[k][j][i] = ta1[iel][k][j][i]+dtime2*rk1[k][j][i];
}
}
}
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
r2 = pow(xloc[i]-xx0[1],2.0) + pow(yloc[j]-yy0[1],2.0) +
pow(zloc[k]-zz0[1],2.0);
if (r2 <= alpha2) {
src = cos(sqrt(r2)*pidivalpha)+1.0;
} else {
src = 0.0;
}
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][i] * temp[k][j][ip];
}
dtx1 = -VELX*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][j] * temp[k][ip][i];
}
dtx2 = -VELY*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][k] * temp[ip][j][i];
}
dtx3 = -VELZ*sum*xrm1_s[isize][k][j][i];
rk2[k][j][i] = dtx1 + dtx2 + dtx3 + src;
tempa[k][j][i] = ta1[iel][k][j][i]+dtime2*rk2[k][j][i];
}
}
}
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
r2 = pow(xloc[i]-xx0[1],2.0) + pow(yloc[j]-yy0[1],2.0) +
pow(zloc[k]-zz0[1],2.0);
if (r2 <= alpha2) {
src = cos(sqrt(r2)*pidivalpha)+1.0;
} else {
src = 0.0;
}
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][i] * tempa[k][j][ip];
}
dtx1 = -VELX*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][j] * tempa[k][ip][i];
}
dtx2 = -VELY*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][k] * tempa[ip][j][i];
}
dtx3 = -VELZ*sum*xrm1_s[isize][k][j][i];
rk3[k][j][i] = dtx1 + dtx2 + dtx3 + src;
temp[k][j][i] = ta1[iel][k][j][i]+dtime*rk3[k][j][i];
}
}
}
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
r2 = pow(xloc[i]-xx0[2],2.0) + pow(yloc[j]-yy0[2],2.0) +
pow(zloc[k]-zz0[2],2.0);
if (r2 <= alpha2) {
src = cos(sqrt(r2)*pidivalpha)+1.0;
} else {
src = 0.0;
}
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][i] * temp[k][j][ip];
}
dtx1 = -VELX*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][j] * temp[k][ip][i];
}
dtx2 = -VELY*sum*xrm1_s[isize][k][j][i];
sum = 0.0;
for (ip = 0; ip < LX1; ip++) {
sum = sum + dxm1[ip][k] * temp[ip][j][i];
}
dtx3 = -VELZ*sum*xrm1_s[isize][k][j][i];
rk4[k][j][i] = dtx1 + dtx2 + dtx3 + src;
tempa[k][j][i] = sixth*(rk1[k][j][i]+2.0*
rk2[k][j][i]+2.0*rk3[k][j][i]+rk4[k][j][i]);
}
}
}
// apply boundary condition
for (iside = 0; iside < NSIDES; iside++) {
if(cbc[iel][iside] == 0) {
facev(tempa, iside, 0.0);
}
}
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
trhs[iel][k][j][i]=bm1_s[isize][k][j][i]*(ta1[iel][k][j][i]*rdtime+
tempa[k][j][i]);
ta1[iel][k][j][i]=ta1[iel][k][j][i]+tempa[k][j][i]*dtime;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(rk4,rk3,rk2,temp,rk1,dtx3,\<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/convect.c | #pragma omp parallel for default(shared) private(i) | 100 | ble *)ta1);
} else {
transfb_c((double *)ta1);
}
if (timeron) timer_stop(t_transfb_c);
<LOOP-START>for (i = 0; i < nmor; i++) {
tmort[i] = tmort[i] / mormult[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/ua.c | #pragma omp parallel for default(shared) private(ie,iside) | 100 | condition: zero out the residual on domain boundaries
// apply boundary conidtion to trhs
<LOOP-START>for (ie = 0; ie < nelt; ie++) {
for (iside = 0; iside < NSIDES; iside++) {
if (cbc[ie][iside] == 0) {
facev(trhs[ie], iside, 0.0);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ie,iside)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/setup.c | #pragma omp parallel for default(shared) private(isize,temp,temp1,temp2, \ | 100 | isize, i, j, k, ntemp, iel;
for (i = 0; i < LX1; i++) {
xfrac[i] = zgm1[i]*0.5 + 0.5;
}
<LOOP-START>k,j,i,dtemp)
for (isize = 0; isize < REFINE_MAX; isize++) {
temp = pow(2.0, (-isize-2));
dtemp = 1.0/temp;
temp1 = temp*temp*temp;
temp2 = temp*temp;
for (k = 0; k < LX1; k++) {
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
xrm1_s[isize][k][j][i] = dtemp;
jacm1_s[isize][k][j][i] = temp1;
rxm1_s[isize][k][j][i] = temp2;
g1m1_s[isize][k][j][i] = w3m1[k][j][i]*temp;
bm1_s[isize][k][j][i] = w3m1[k][j][i]*temp1;
g4m1_s[isize][k][j][i] = g1m1_s[isize][k][j][i]/wxm1[i];
g5m1_s[isize][k][j][i] = g1m1_s[isize][k][j][i]/wxm1[j];
g6m1_s[isize][k][j][i] = g1m1_s[isize][k][j][i]/wxm1[k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(isize,temp,temp1,temp2, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/setup.c | #pragma omp parallel for default(shared) private(ntemp,i,j,iel) | 100 | ;
g6m1_s[isize][k][j][i] = g1m1_s[isize][k][j][i]/wxm1[k];
}
}
}
}
<LOOP-START>for (iel = 0; iel < LELT; iel++) {
ntemp = LX1*LX1*LX1*iel;
for (j = 0; j < LX1; j++) {
for (i = 0; i < LX1; i++) {
idel[iel][0][j][i] = ntemp+i*LX1 + j*LX1*LX1+LX1 - 1;
idel[iel][1][j][i] = ntemp+i*LX1 + j*LX1*LX1;
idel[iel][2][j][i] = ntemp+i*1 + j*LX1*LX1+LX1*(LX1-1);
idel[iel][3][j][i] = ntemp+i*1 + j*LX1*LX1;
idel[iel][4][j][i] = ntemp+i*1 + j*LX1+LX1*LX1*(LX1-1);
idel[iel][5][j][i] = ntemp+i*1 + j*LX1;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ntemp,i,j,iel)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/transfer.c | #pragma omp parallel for default(shared) private(i) | 100 | ---------------------------------
void init_locks()
{
int i;
// initialize locks in parallel
<LOOP-START>for (i = 0; i < LMOR; i++) {
omp_init_lock(&tlock[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/UA/transfer.c | #pragma omp parallel for default(shared) private(il,j,ig,i,col,ije2,ije1, \ | 100 | 2, col, i, j, ig, il;
// zero out tx on element boundaries
col2(tx, (double *)tmult, ntot);
<LOOP-START>ig4,ig3,ig2,ig1,nnje,il4,il3,il2,il1,iface,ie,tmp)
for (ie = 0; ie < nelt; ie++) {
for (iface = 0; iface < NSIDES; iface++) {
// get the collocation point index of the four local corners on the
// face iface of element ie
il1 = idel[ie][iface][0][0];
il2 = idel[ie][iface][0][LX1-1];
il3 = idel[ie][iface][LX1-1][0];
il4 = idel[ie][iface][LX1-1][LX1-1];
// get the mortar indices of the four local corners
ig1 = idmo[ie][iface][0][0][0][0];
ig2 = idmo[ie][iface][1][0][0][LX1-1];
ig3 = idmo[ie][iface][0][1][LX1-1][0];
ig4 = idmo[ie][iface][1][1][LX1-1][LX1-1];
// copy the value from tmor to tx for these four local corners
tx[il1] = tmor[ig1];
tx[il2] = tmor[ig2];
tx[il3] = tmor[ig3];
tx[il4] = tmor[ig4];
// nnje=1 for conforming faces, nnje=2 for nonconforming faces
if (cbc[ie][iface] == 3) {
nnje = 2;
} else {
nnje = 1;
}
// for nonconforming faces
if (nnje == 2) {
// nonconforming faces have four pieces of mortar, first map them to
// two intermediate mortars, stored in tmp
r_init((double *)tmp, LX1*LX1*2, 0.0);
for (ije1 = 0; ije1 < nnje; ije1++) {
for (ije2 = 0; ije2 < nnje; ije2++) {
for (col = 0; col < LX1; col++) {
// in each row col, when coloumn i=1 or LX1, the value
// in tmor is copied to tmp
i = v_end[ije2];
ig = idmo[ie][iface][ije2][ije1][col][i];
tmp[ije1][col][i] = tmor[ig];
// in each row col, value in the interior three collocation
// points is computed by apply mapping matrix qbnew to tmor
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][col][i];
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije2][ije1][col][j];
tmp[ije1][col][i] = tmp[ije1][col][i] +
qbnew[ije2][j][i-1]*tmor[ig];
}
}
}
}
}
// mapping from two pieces of intermediate mortar tmp to element
// face tx
for (ije1 = 0; ije1 < nnje; ije1++) {
// the first column, col=0, is an edge of face iface.
// the value on the three interior collocation points, tx, is
// computed by applying mapping matrices qbnew to tmp.
// the mapping result is divided by 2, because there will be
// duplicated contribution from another face sharing this edge.
col = 0;
for (i = 1; i < LX1-1; i++) {
il= idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]*
tmp[ije1][j][col]*0.5;
}
}
// for column 1 ~ lx-2
for (col = 1; col < LX1-1; col++) {
//when i=0 or LX1-1, the collocation points are also on an edge of
// the face, so the mapping result also needs to be divided by 2
i = v_end[ije1];
il = idel[ie][iface][i][col];
tx[il] = tx[il]+tmp[ije1][i][col]*0.5;
// compute the value at interior collocation points in
// columns 1 ~ LX1-1
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]* tmp[ije1][j][col];
}
}
}
// same as col=0
col = LX1-1;
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][col];
for (j = 0; j < LX1; j++) {
tx[il] = tx[il] + qbnew[ije1][j][i-1]*
tmp[ije1][j][col]*0.5;
}
}
}
// for conforming faces
} else {
// face interior
for (col = 1; col < LX1-1; col++) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][col][i];
ig = idmo[ie][iface][0][0][col][i];
tx[il] = tmor[ig];
}
}
// edges of conforming faces
// if local edge 0 is a nonconforming edge
if (idmo[ie][iface][0][0][0][LX1-1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][0][i];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije1][0][0][j];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 0 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][0][i];
ig = idmo[ie][iface][0][0][0][i];
tx[il] = tmor[ig];
}
}
// if local edge 1 is a nonconforming edge
if (idmo[ie][iface][1][0][1][LX1-1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][LX1-1];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][1][ije1][j][LX1-1];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 1 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][LX1-1];
ig = idmo[ie][iface][0][0][i][LX1-1];
tx[il] = tmor[ig];
}
}
// if local edge 2 is a nonconforming edge
if (idmo[ie][iface][0][1][LX1-1][1] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][LX1-1][i];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][ije1][1][LX1-1][j];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 2 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][LX1-1][i];
ig = idmo[ie][iface][0][0][LX1-1][i];
tx[il] = tmor[ig];
}
}
// if local edge 3 is a nonconforming edge
if (idmo[ie][iface][0][0][LX1-1][0] != -1) {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][0];
for (ije1 = 0; ije1 < 2; ije1++) {
for (j = 0; j < LX1; j++) {
ig = idmo[ie][iface][0][ije1][j][0];
tx[il] = tx[il] + qbnew[ije1][j][i-1]*tmor[ig]*0.5;
}
}
}
// if local edge 3 is a conforming edge
} else {
for (i = 1; i < LX1-1; i++) {
il = idel[ie][iface][i][0];
ig = idmo[ie][iface][0][0][i][0];
tx[il] = tmor[ig];
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(il,j,ig,i,col,ije2,ije1, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/pinvr.c | #pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2) | 100 | nvr()
{
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
if (timeron) timer_start(t_pinvr);
<LOOP-START>for (k = 1; k <= nz2; k++) {
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
r1 = rhs[k][j][i][0];
r2 = rhs[k][j][i][1];
r3 = rhs[k][j][i][2];
r4 = rhs[k][j][i][3];
r5 = rhs[k][j][i][4];
t1 = bt * r1;
t2 = 0.5 * ( r4 + r5 );
rhs[k][j][i][0] = bt * ( r4 - r5 );
rhs[k][j][i][1] = -r3;
rhs[k][j][i][2] = r2;
rhs[k][j][i][3] = -t1 + t2;
rhs[k][j][i][4] = t1 + t2;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/x_solve.c | #pragma omp parallel for default(shared) private(i,j,k,i1,i2,m, \ | 100 | ve()
{
int i, j, k, i1, i2, m;
double ru1, fac1, fac2;
if (timeron) timer_start(t_xsolve);
<LOOP-START>ru1,fac1,fac2)
for (k = 1; k <= nz2; k++) {
lhsinit(nx2+1, ny2);
//---------------------------------------------------------------------
// Computes the left hand side for the three x-factors
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// first fill the lhs for the u-eigenvalue
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
for (i = 0; i <= grid_points[0]-1; i++) {
ru1 = c3c4*rho_i[k][j][i];
cv[i] = us[k][j][i];
rhon[i] = max(max(dx2+con43*ru1,dx5+c1c5*ru1), max(dxmax+ru1,dx1));
}
for (i = 1; i <= nx2; i++) {
lhs[j][i][0] = 0.0;
lhs[j][i][1] = -dttx2 * cv[i-1] - dttx1 * rhon[i-1];
lhs[j][i][2] = 1.0 + c2dttx1 * rhon[i];
lhs[j][i][3] = dttx2 * cv[i+1] - dttx1 * rhon[i+1];
lhs[j][i][4] = 0.0;
}
}
//---------------------------------------------------------------------
// add fourth order dissipation
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
i = 1;
lhs[j][i][2] = lhs[j][i][2] + comz5;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j][i][4] = lhs[j][i][4] + comz1;
lhs[j][i+1][1] = lhs[j][i+1][1] - comz4;
lhs[j][i+1][2] = lhs[j][i+1][2] + comz6;
lhs[j][i+1][3] = lhs[j][i+1][3] - comz4;
lhs[j][i+1][4] = lhs[j][i+1][4] + comz1;
}
for (j = 1; j <= ny2; j++) {
for (i = 3; i <= grid_points[0]-4; i++) {
lhs[j][i][0] = lhs[j][i][0] + comz1;
lhs[j][i][1] = lhs[j][i][1] - comz4;
lhs[j][i][2] = lhs[j][i][2] + comz6;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j][i][4] = lhs[j][i][4] + comz1;
}
}
for (j = 1; j <= ny2; j++) {
i = grid_points[0]-3;
lhs[j][i][0] = lhs[j][i][0] + comz1;
lhs[j][i][1] = lhs[j][i][1] - comz4;
lhs[j][i][2] = lhs[j][i][2] + comz6;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j][i+1][0] = lhs[j][i+1][0] + comz1;
lhs[j][i+1][1] = lhs[j][i+1][1] - comz4;
lhs[j][i+1][2] = lhs[j][i+1][2] + comz5;
}
//---------------------------------------------------------------------
// subsequently, fill the other factors (u+c), (u-c) by adding to
// the first
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
lhsp[j][i][0] = lhs[j][i][0];
lhsp[j][i][1] = lhs[j][i][1] - dttx2 * speed[k][j][i-1];
lhsp[j][i][2] = lhs[j][i][2];
lhsp[j][i][3] = lhs[j][i][3] + dttx2 * speed[k][j][i+1];
lhsp[j][i][4] = lhs[j][i][4];
lhsm[j][i][0] = lhs[j][i][0];
lhsm[j][i][1] = lhs[j][i][1] + dttx2 * speed[k][j][i-1];
lhsm[j][i][2] = lhs[j][i][2];
lhsm[j][i][3] = lhs[j][i][3] - dttx2 * speed[k][j][i+1];
lhsm[j][i][4] = lhs[j][i][4];
}
}
//---------------------------------------------------------------------
// FORWARD ELIMINATION
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// perform the Thomas algorithm; first, FORWARD ELIMINATION
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
for (i = 0; i <= grid_points[0]-3; i++) {
i1 = i + 1;
i2 = i + 2;
fac1 = 1.0/lhs[j][i][2];
lhs[j][i][3] = fac1*lhs[j][i][3];
lhs[j][i][4] = fac1*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[j][i1][2] = lhs[j][i1][2] - lhs[j][i1][1]*lhs[j][i][3];
lhs[j][i1][3] = lhs[j][i1][3] - lhs[j][i1][1]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhs[j][i1][1]*rhs[k][j][i][m];
}
lhs[j][i2][1] = lhs[j][i2][1] - lhs[j][i2][0]*lhs[j][i][3];
lhs[j][i2][2] = lhs[j][i2][2] - lhs[j][i2][0]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i2][m] = rhs[k][j][i2][m] - lhs[j][i2][0]*rhs[k][j][i][m];
}
}
}
//---------------------------------------------------------------------
// The last two rows in this grid block are a bit different,
// since they for (not have two more rows available for the
// elimination of off-diagonal entries
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
i = grid_points[0]-2;
i1 = grid_points[0]-1;
fac1 = 1.0/lhs[j][i][2];
lhs[j][i][3] = fac1*lhs[j][i][3];
lhs[j][i][4] = fac1*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[j][i1][2] = lhs[j][i1][2] - lhs[j][i1][1]*lhs[j][i][3];
lhs[j][i1][3] = lhs[j][i1][3] - lhs[j][i1][1]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhs[j][i1][1]*rhs[k][j][i][m];
}
//---------------------------------------------------------------------
// scale the last row immediately
//---------------------------------------------------------------------
fac2 = 1.0/lhs[j][i1][2];
for (m = 0; m < 3; m++) {
rhs[k][j][i1][m] = fac2*rhs[k][j][i1][m];
}
}
//---------------------------------------------------------------------
// for (the u+c and the u-c factors
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
for (i = 0; i <= grid_points[0]-3; i++) {
i1 = i + 1;
i2 = i + 2;
m = 3;
fac1 = 1.0/lhsp[j][i][2];
lhsp[j][i][3] = fac1*lhsp[j][i][3];
lhsp[j][i][4] = fac1*lhsp[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[j][i1][2] = lhsp[j][i1][2] - lhsp[j][i1][1]*lhsp[j][i][3];
lhsp[j][i1][3] = lhsp[j][i1][3] - lhsp[j][i1][1]*lhsp[j][i][4];
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhsp[j][i1][1]*rhs[k][j][i][m];
lhsp[j][i2][1] = lhsp[j][i2][1] - lhsp[j][i2][0]*lhsp[j][i][3];
lhsp[j][i2][2] = lhsp[j][i2][2] - lhsp[j][i2][0]*lhsp[j][i][4];
rhs[k][j][i2][m] = rhs[k][j][i2][m] - lhsp[j][i2][0]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[j][i][2];
lhsm[j][i][3] = fac1*lhsm[j][i][3];
lhsm[j][i][4] = fac1*lhsm[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[j][i1][2] = lhsm[j][i1][2] - lhsm[j][i1][1]*lhsm[j][i][3];
lhsm[j][i1][3] = lhsm[j][i1][3] - lhsm[j][i1][1]*lhsm[j][i][4];
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhsm[j][i1][1]*rhs[k][j][i][m];
lhsm[j][i2][1] = lhsm[j][i2][1] - lhsm[j][i2][0]*lhsm[j][i][3];
lhsm[j][i2][2] = lhsm[j][i2][2] - lhsm[j][i2][0]*lhsm[j][i][4];
rhs[k][j][i2][m] = rhs[k][j][i2][m] - lhsm[j][i2][0]*rhs[k][j][i][m];
}
}
//---------------------------------------------------------------------
// And again the last two rows separately
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
i = grid_points[0]-2;
i1 = grid_points[0]-1;
m = 3;
fac1 = 1.0/lhsp[j][i][2];
lhsp[j][i][3] = fac1*lhsp[j][i][3];
lhsp[j][i][4] = fac1*lhsp[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[j][i1][2] = lhsp[j][i1][2] - lhsp[j][i1][1]*lhsp[j][i][3];
lhsp[j][i1][3] = lhsp[j][i1][3] - lhsp[j][i1][1]*lhsp[j][i][4];
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhsp[j][i1][1]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[j][i][2];
lhsm[j][i][3] = fac1*lhsm[j][i][3];
lhsm[j][i][4] = fac1*lhsm[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[j][i1][2] = lhsm[j][i1][2] - lhsm[j][i1][1]*lhsm[j][i][3];
lhsm[j][i1][3] = lhsm[j][i1][3] - lhsm[j][i1][1]*lhsm[j][i][4];
rhs[k][j][i1][m] = rhs[k][j][i1][m] - lhsm[j][i1][1]*rhs[k][j][i][m];
//---------------------------------------------------------------------
// Scale the last row immediately
//---------------------------------------------------------------------
rhs[k][j][i1][3] = rhs[k][j][i1][3]/lhsp[j][i1][2];
rhs[k][j][i1][4] = rhs[k][j][i1][4]/lhsm[j][i1][2];
}
//---------------------------------------------------------------------
// BACKSUBSTITUTION
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
i = grid_points[0]-2;
i1 = grid_points[0]-1;
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] - lhs[j][i][3]*rhs[k][j][i1][m];
}
rhs[k][j][i][3] = rhs[k][j][i][3] - lhsp[j][i][3]*rhs[k][j][i1][3];
rhs[k][j][i][4] = rhs[k][j][i][4] - lhsm[j][i][3]*rhs[k][j][i1][4];
}
//---------------------------------------------------------------------
// The first three factors
//---------------------------------------------------------------------
for (j = 1; j <= ny2; j++) {
for (i = grid_points[0]-3; i >= 0; i--) {
i1 = i + 1;
i2 = i + 2;
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] -
lhs[j][i][3]*rhs[k][j][i1][m] -
lhs[j][i][4]*rhs[k][j][i2][m];
}
//-------------------------------------------------------------------
// And the remaining two
//-------------------------------------------------------------------
rhs[k][j][i][3] = rhs[k][j][i][3] -
lhsp[j][i][3]*rhs[k][j][i1][3] -
lhsp[j][i][4]*rhs[k][j][i2][3];
rhs[k][j][i][4] = rhs[k][j][i][4] -
lhsm[j][i][3]*rhs[k][j][i1][4] -
lhsm[j][i][4]*rhs[k][j][i2][4];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,i1,i2,m, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/add.c | #pragma omp parallel for default(shared) private(i,j,k,m) | 100 | ------------------------------
void add()
{
int i, j, k, m;
if (timeron) timer_start(t_add);
<LOOP-START>for (k = 1; k <= nz2; k++) {
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
for (m = 0; m < 5; m++) {
u[k][j][i][m] = u[k][j][i][m] + rhs[k][j][i][m];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,m)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/txinvr.c | #pragma omp parallel for default(shared) \ | 100 | , t2, t3, ac, ru1, uu, vv, ww, r1, r2, r3, r4, r5, ac2inv;
if (timeron) timer_start(t_txinvr);
<LOOP-START>private(i,j,k,t1,t2,t3,ac,ru1,uu,vv,ww,r1,r2,r3,r4,r5,ac2inv)
for (k = 1; k <= nz2; k++) {
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
ru1 = rho_i[k][j][i];
uu = us[k][j][i];
vv = vs[k][j][i];
ww = ws[k][j][i];
ac = speed[k][j][i];
ac2inv = ac*ac;
r1 = rhs[k][j][i][0];
r2 = rhs[k][j][i][1];
r3 = rhs[k][j][i][2];
r4 = rhs[k][j][i][3];
r5 = rhs[k][j][i][4];
t1 = c2 / ac2inv * ( qs[k][j][i]*r1 - uu*r2 - vv*r3 - ww*r4 + r5 );
t2 = bt * ru1 * ( uu * r1 - r2 );
t3 = ( bt * ru1 * ac ) * t1;
rhs[k][j][i][0] = r1 - t1;
rhs[k][j][i][1] = - ru1 * ( ww*r1 - r4 );
rhs[k][j][i][2] = ru1 * ( vv*r1 - r3 );
rhs[k][j][i][3] = - t2 + t3;
rhs[k][j][i][4] = t2 + t3;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/ninvr.c | #pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2) | 100 | nvr()
{
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
if (timeron) timer_start(t_ninvr);
<LOOP-START>for (k = 1; k <= nz2; k++) {
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
r1 = rhs[k][j][i][0];
r2 = rhs[k][j][i][1];
r3 = rhs[k][j][i][2];
r4 = rhs[k][j][i][3];
r5 = rhs[k][j][i][4];
t1 = bt * r3;
t2 = 0.5 * ( r4 + r5 );
rhs[k][j][i][0] = -r2;
rhs[k][j][i][1] = r1;
rhs[k][j][i][2] = bt * ( r4 - r5 );
rhs[k][j][i][3] = -t1 + t2;
rhs[k][j][i][4] = t1 + t2;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/z_solve.c | #pragma omp parallel for default(shared) private(i,j,k,k1,k2,m, \ | 100 | ----------------------------------------------------------
if (timeron) timer_start(t_zsolve);
<LOOP-START>ru1,fac1,fac2)
for (j = 1; j <= ny2; j++) {
lhsinitj(nz2+1, nx2);
//---------------------------------------------------------------------
// Computes the left hand side for the three z-factors
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// first fill the lhs for the u-eigenvalue
//---------------------------------------------------------------------
for (i = 1; i <= nx2; i++) {
for (k = 0; k <= nz2+1; k++) {
ru1 = c3c4*rho_i[k][j][i];
cv[k] = ws[k][j][i];
rhos[k] = max(max(dz4+con43*ru1, dz5+c1c5*ru1), max(dzmax+ru1, dz1));
}
for (k = 1; k <= nz2; k++) {
lhs[k][i][0] = 0.0;
lhs[k][i][1] = -dttz2 * cv[k-1] - dttz1 * rhos[k-1];
lhs[k][i][2] = 1.0 + c2dttz1 * rhos[k];
lhs[k][i][3] = dttz2 * cv[k+1] - dttz1 * rhos[k+1];
lhs[k][i][4] = 0.0;
}
}
//---------------------------------------------------------------------
// add fourth order dissipation
//---------------------------------------------------------------------
for (i = 1; i <= nx2; i++) {
k = 1;
lhs[k][i][2] = lhs[k][i][2] + comz5;
lhs[k][i][3] = lhs[k][i][3] - comz4;
lhs[k][i][4] = lhs[k][i][4] + comz1;
k = 2;
lhs[k][i][1] = lhs[k][i][1] - comz4;
lhs[k][i][2] = lhs[k][i][2] + comz6;
lhs[k][i][3] = lhs[k][i][3] - comz4;
lhs[k][i][4] = lhs[k][i][4] + comz1;
}
for (k = 3; k <= nz2-2; k++) {
for (i = 1; i <= nx2; i++) {
lhs[k][i][0] = lhs[k][i][0] + comz1;
lhs[k][i][1] = lhs[k][i][1] - comz4;
lhs[k][i][2] = lhs[k][i][2] + comz6;
lhs[k][i][3] = lhs[k][i][3] - comz4;
lhs[k][i][4] = lhs[k][i][4] + comz1;
}
}
for (i = 1; i <= nx2; i++) {
k = nz2-1;
lhs[k][i][0] = lhs[k][i][0] + comz1;
lhs[k][i][1] = lhs[k][i][1] - comz4;
lhs[k][i][2] = lhs[k][i][2] + comz6;
lhs[k][i][3] = lhs[k][i][3] - comz4;
k = nz2;
lhs[k][i][0] = lhs[k][i][0] + comz1;
lhs[k][i][1] = lhs[k][i][1] - comz4;
lhs[k][i][2] = lhs[k][i][2] + comz5;
}
//---------------------------------------------------------------------
// subsequently, fill the other factors (u+c), (u-c)
//---------------------------------------------------------------------
for (k = 1; k <= nz2; k++) {
for (i = 1; i <= nx2; i++) {
lhsp[k][i][0] = lhs[k][i][0];
lhsp[k][i][1] = lhs[k][i][1] - dttz2 * speed[k-1][j][i];
lhsp[k][i][2] = lhs[k][i][2];
lhsp[k][i][3] = lhs[k][i][3] + dttz2 * speed[k+1][j][i];
lhsp[k][i][4] = lhs[k][i][4];
lhsm[k][i][0] = lhs[k][i][0];
lhsm[k][i][1] = lhs[k][i][1] + dttz2 * speed[k-1][j][i];
lhsm[k][i][2] = lhs[k][i][2];
lhsm[k][i][3] = lhs[k][i][3] - dttz2 * speed[k+1][j][i];
lhsm[k][i][4] = lhs[k][i][4];
}
}
//---------------------------------------------------------------------
// FORWARD ELIMINATION
//---------------------------------------------------------------------
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
for (i = 1; i <= nx2; i++) {
fac1 = 1.0/lhs[k][i][2];
lhs[k][i][3] = fac1*lhs[k][i][3];
lhs[k][i][4] = fac1*lhs[k][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[k1][i][2] = lhs[k1][i][2] - lhs[k1][i][1]*lhs[k][i][3];
lhs[k1][i][3] = lhs[k1][i][3] - lhs[k1][i][1]*lhs[k][i][4];
for (m = 0; m < 3; m++) {
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhs[k1][i][1]*rhs[k][j][i][m];
}
lhs[k2][i][1] = lhs[k2][i][1] - lhs[k2][i][0]*lhs[k][i][3];
lhs[k2][i][2] = lhs[k2][i][2] - lhs[k2][i][0]*lhs[k][i][4];
for (m = 0; m < 3; m++) {
rhs[k2][j][i][m] = rhs[k2][j][i][m] - lhs[k2][i][0]*rhs[k][j][i][m];
}
}
}
//---------------------------------------------------------------------
// The last two rows in this grid block are a bit different,
// since they for (not have two more rows available for the
// elimination of off-diagonal entries
//---------------------------------------------------------------------
k = grid_points[2]-2;
k1 = grid_points[2]-1;
for (i = 1; i <= nx2; i++) {
fac1 = 1.0/lhs[k][i][2];
lhs[k][i][3] = fac1*lhs[k][i][3];
lhs[k][i][4] = fac1*lhs[k][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[k1][i][2] = lhs[k1][i][2] - lhs[k1][i][1]*lhs[k][i][3];
lhs[k1][i][3] = lhs[k1][i][3] - lhs[k1][i][1]*lhs[k][i][4];
for (m = 0; m < 3; m++) {
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhs[k1][i][1]*rhs[k][j][i][m];
}
//---------------------------------------------------------------------
// scale the last row immediately
//---------------------------------------------------------------------
fac2 = 1.0/lhs[k1][i][2];
for (m = 0; m < 3; m++) {
rhs[k1][j][i][m] = fac2*rhs[k1][j][i][m];
}
}
//---------------------------------------------------------------------
// for (the u+c and the u-c factors
//---------------------------------------------------------------------
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
for (i = 1; i <= nx2; i++) {
m = 3;
fac1 = 1.0/lhsp[k][i][2];
lhsp[k][i][3] = fac1*lhsp[k][i][3];
lhsp[k][i][4] = fac1*lhsp[k][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[k1][i][2] = lhsp[k1][i][2] - lhsp[k1][i][1]*lhsp[k][i][3];
lhsp[k1][i][3] = lhsp[k1][i][3] - lhsp[k1][i][1]*lhsp[k][i][4];
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhsp[k1][i][1]*rhs[k][j][i][m];
lhsp[k2][i][1] = lhsp[k2][i][1] - lhsp[k2][i][0]*lhsp[k][i][3];
lhsp[k2][i][2] = lhsp[k2][i][2] - lhsp[k2][i][0]*lhsp[k][i][4];
rhs[k2][j][i][m] = rhs[k2][j][i][m] - lhsp[k2][i][0]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[k][i][2];
lhsm[k][i][3] = fac1*lhsm[k][i][3];
lhsm[k][i][4] = fac1*lhsm[k][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[k1][i][2] = lhsm[k1][i][2] - lhsm[k1][i][1]*lhsm[k][i][3];
lhsm[k1][i][3] = lhsm[k1][i][3] - lhsm[k1][i][1]*lhsm[k][i][4];
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhsm[k1][i][1]*rhs[k][j][i][m];
lhsm[k2][i][1] = lhsm[k2][i][1] - lhsm[k2][i][0]*lhsm[k][i][3];
lhsm[k2][i][2] = lhsm[k2][i][2] - lhsm[k2][i][0]*lhsm[k][i][4];
rhs[k2][j][i][m] = rhs[k2][j][i][m] - lhsm[k2][i][0]*rhs[k][j][i][m];
}
}
//---------------------------------------------------------------------
// And again the last two rows separately
//---------------------------------------------------------------------
k = grid_points[2]-2;
k1 = grid_points[2]-1;
for (i = 1; i <= nx2; i++) {
m = 3;
fac1 = 1.0/lhsp[k][i][2];
lhsp[k][i][3] = fac1*lhsp[k][i][3];
lhsp[k][i][4] = fac1*lhsp[k][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[k1][i][2] = lhsp[k1][i][2] - lhsp[k1][i][1]*lhsp[k][i][3];
lhsp[k1][i][3] = lhsp[k1][i][3] - lhsp[k1][i][1]*lhsp[k][i][4];
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhsp[k1][i][1]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[k][i][2];
lhsm[k][i][3] = fac1*lhsm[k][i][3];
lhsm[k][i][4] = fac1*lhsm[k][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[k1][i][2] = lhsm[k1][i][2] - lhsm[k1][i][1]*lhsm[k][i][3];
lhsm[k1][i][3] = lhsm[k1][i][3] - lhsm[k1][i][1]*lhsm[k][i][4];
rhs[k1][j][i][m] = rhs[k1][j][i][m] - lhsm[k1][i][1]*rhs[k][j][i][m];
//---------------------------------------------------------------------
// Scale the last row immediately (some of this is overkill
// if this is the last cell)
//---------------------------------------------------------------------
rhs[k1][j][i][3] = rhs[k1][j][i][3]/lhsp[k1][i][2];
rhs[k1][j][i][4] = rhs[k1][j][i][4]/lhsm[k1][i][2];
}
//---------------------------------------------------------------------
// BACKSUBSTITUTION
//---------------------------------------------------------------------
k = grid_points[2]-2;
k1 = grid_points[2]-1;
for (i = 1; i <= nx2; i++) {
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] - lhs[k][i][3]*rhs[k1][j][i][m];
}
rhs[k][j][i][3] = rhs[k][j][i][3] - lhsp[k][i][3]*rhs[k1][j][i][3];
rhs[k][j][i][4] = rhs[k][j][i][4] - lhsm[k][i][3]*rhs[k1][j][i][4];
}
//---------------------------------------------------------------------
// Whether or not this is the last processor, we always have
// to complete the back-substitution
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// The first three factors
//---------------------------------------------------------------------
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
for (i = 1; i <= nx2; i++) {
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] -
lhs[k][i][3]*rhs[k1][j][i][m] -
lhs[k][i][4]*rhs[k2][j][i][m];
}
//-------------------------------------------------------------------
// And the remaining two
//-------------------------------------------------------------------
rhs[k][j][i][3] = rhs[k][j][i][3] -
lhsp[k][i][3]*rhs[k1][j][i][3] -
lhsp[k][i][4]*rhs[k2][j][i][3];
rhs[k][j][i][4] = rhs[k][j][i][4] -
lhsm[k][i][3]*rhs[k1][j][i][4] -
lhsm[k][i][4]*rhs[k2][j][i][4];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,k1,k2,m, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/tzetar.c | #pragma omp parallel for default(shared) \ | 100 | vel, zvel, r1, r2, r3, r4, r5;
double btuz, ac2u, uzik1;
if (timeron) timer_start(t_tzetar);
<LOOP-START>private(i,j,k,t1,t2,t3,ac,xvel,yvel,zvel,r1,r2,r3,r4,r5,btuz,ac2u,uzik1)
for (k = 1; k <= nz2; k++) {
for (j = 1; j <= ny2; j++) {
for (i = 1; i <= nx2; i++) {
xvel = us[k][j][i];
yvel = vs[k][j][i];
zvel = ws[k][j][i];
ac = speed[k][j][i];
ac2u = ac*ac;
r1 = rhs[k][j][i][0];
r2 = rhs[k][j][i][1];
r3 = rhs[k][j][i][2];
r4 = rhs[k][j][i][3];
r5 = rhs[k][j][i][4];
uzik1 = u[k][j][i][0];
btuz = bt * uzik1;
t1 = btuz/ac * (r4 + r5);
t2 = r3 + t1;
t3 = btuz * (r4 - r5);
rhs[k][j][i][0] = t2;
rhs[k][j][i][1] = -uzik1*r2 + xvel*t2;
rhs[k][j][i][2] = uzik1*r1 + yvel*t2;
rhs[k][j][i][3] = zvel*t2 + t3;
rhs[k][j][i][4] = uzik1*(-xvel*r2 + yvel*r1) +
qs[k][j][i]*t2 + c2iv*ac2u*t1 + zvel*t3;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/SP/y_solve.c | #pragma omp parallel for default(shared) private(i,j,k,j1,j2,m, \ | 100 | ve()
{
int i, j, k, j1, j2, m;
double ru1, fac1, fac2;
if (timeron) timer_start(t_ysolve);
<LOOP-START>ru1,fac1,fac2)
for (k = 1; k <= nz2; k++) {
lhsinitj(ny2+1, nx2);
//---------------------------------------------------------------------
// Computes the left hand side for the three y-factors
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// first fill the lhs for the u-eigenvalue
//---------------------------------------------------------------------
for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 0; j <= grid_points[1]-1; j++) {
ru1 = c3c4*rho_i[k][j][i];
cv[j] = vs[k][j][i];
rhoq[j] = max(max(dy3+con43*ru1, dy5+c1c5*ru1), max(dymax+ru1, dy1));
}
for (j = 1; j <= grid_points[1]-2; j++) {
lhs[j][i][0] = 0.0;
lhs[j][i][1] = -dtty2 * cv[j-1] - dtty1 * rhoq[j-1];
lhs[j][i][2] = 1.0 + c2dtty1 * rhoq[j];
lhs[j][i][3] = dtty2 * cv[j+1] - dtty1 * rhoq[j+1];
lhs[j][i][4] = 0.0;
}
}
//---------------------------------------------------------------------
// add fourth order dissipation
//---------------------------------------------------------------------
for (i = 1; i <= grid_points[0]-2; i++) {
j = 1;
lhs[j][i][2] = lhs[j][i][2] + comz5;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j][i][4] = lhs[j][i][4] + comz1;
lhs[j+1][i][1] = lhs[j+1][i][1] - comz4;
lhs[j+1][i][2] = lhs[j+1][i][2] + comz6;
lhs[j+1][i][3] = lhs[j+1][i][3] - comz4;
lhs[j+1][i][4] = lhs[j+1][i][4] + comz1;
}
for (j = 3; j <= grid_points[1]-4; j++) {
for (i = 1; i <= grid_points[0]-2; i++) {
lhs[j][i][0] = lhs[j][i][0] + comz1;
lhs[j][i][1] = lhs[j][i][1] - comz4;
lhs[j][i][2] = lhs[j][i][2] + comz6;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j][i][4] = lhs[j][i][4] + comz1;
}
}
for (i = 1; i <= grid_points[0]-2; i++) {
j = grid_points[1]-3;
lhs[j][i][0] = lhs[j][i][0] + comz1;
lhs[j][i][1] = lhs[j][i][1] - comz4;
lhs[j][i][2] = lhs[j][i][2] + comz6;
lhs[j][i][3] = lhs[j][i][3] - comz4;
lhs[j+1][i][0] = lhs[j+1][i][0] + comz1;
lhs[j+1][i][1] = lhs[j+1][i][1] - comz4;
lhs[j+1][i][2] = lhs[j+1][i][2] + comz5;
}
//---------------------------------------------------------------------
// subsequently, for (the other two factors
//---------------------------------------------------------------------
for (j = 1; j <= grid_points[1]-2; j++) {
for (i = 1; i <= grid_points[0]-2; i++) {
lhsp[j][i][0] = lhs[j][i][0];
lhsp[j][i][1] = lhs[j][i][1] - dtty2 * speed[k][j-1][i];
lhsp[j][i][2] = lhs[j][i][2];
lhsp[j][i][3] = lhs[j][i][3] + dtty2 * speed[k][j+1][i];
lhsp[j][i][4] = lhs[j][i][4];
lhsm[j][i][0] = lhs[j][i][0];
lhsm[j][i][1] = lhs[j][i][1] + dtty2 * speed[k][j-1][i];
lhsm[j][i][2] = lhs[j][i][2];
lhsm[j][i][3] = lhs[j][i][3] - dtty2 * speed[k][j+1][i];
lhsm[j][i][4] = lhs[j][i][4];
}
}
//---------------------------------------------------------------------
// FORWARD ELIMINATION
//---------------------------------------------------------------------
for (j = 0; j <= grid_points[1]-3; j++) {
j1 = j + 1;
j2 = j + 2;
for (i = 1; i <= grid_points[0]-2; i++) {
fac1 = 1.0/lhs[j][i][2];
lhs[j][i][3] = fac1*lhs[j][i][3];
lhs[j][i][4] = fac1*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[j1][i][2] = lhs[j1][i][2] - lhs[j1][i][1]*lhs[j][i][3];
lhs[j1][i][3] = lhs[j1][i][3] - lhs[j1][i][1]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhs[j1][i][1]*rhs[k][j][i][m];
}
lhs[j2][i][1] = lhs[j2][i][1] - lhs[j2][i][0]*lhs[j][i][3];
lhs[j2][i][2] = lhs[j2][i][2] - lhs[j2][i][0]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j2][i][m] = rhs[k][j2][i][m] - lhs[j2][i][0]*rhs[k][j][i][m];
}
}
}
//---------------------------------------------------------------------
// The last two rows in this grid block are a bit different,
// since they for (not have two more rows available for the
// elimination of off-diagonal entries
//---------------------------------------------------------------------
j = grid_points[1]-2;
j1 = grid_points[1]-1;
for (i = 1; i <= grid_points[0]-2; i++) {
fac1 = 1.0/lhs[j][i][2];
lhs[j][i][3] = fac1*lhs[j][i][3];
lhs[j][i][4] = fac1*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
}
lhs[j1][i][2] = lhs[j1][i][2] - lhs[j1][i][1]*lhs[j][i][3];
lhs[j1][i][3] = lhs[j1][i][3] - lhs[j1][i][1]*lhs[j][i][4];
for (m = 0; m < 3; m++) {
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhs[j1][i][1]*rhs[k][j][i][m];
}
//---------------------------------------------------------------------
// scale the last row immediately
//---------------------------------------------------------------------
fac2 = 1.0/lhs[j1][i][2];
for (m = 0; m < 3; m++) {
rhs[k][j1][i][m] = fac2*rhs[k][j1][i][m];
}
}
//---------------------------------------------------------------------
// for (the u+c and the u-c factors
//---------------------------------------------------------------------
for (j = 0; j <= grid_points[1]-3; j++) {
j1 = j + 1;
j2 = j + 2;
for (i = 1; i <= grid_points[0]-2; i++) {
m = 3;
fac1 = 1.0/lhsp[j][i][2];
lhsp[j][i][3] = fac1*lhsp[j][i][3];
lhsp[j][i][4] = fac1*lhsp[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[j1][i][2] = lhsp[j1][i][2] - lhsp[j1][i][1]*lhsp[j][i][3];
lhsp[j1][i][3] = lhsp[j1][i][3] - lhsp[j1][i][1]*lhsp[j][i][4];
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhsp[j1][i][1]*rhs[k][j][i][m];
lhsp[j2][i][1] = lhsp[j2][i][1] - lhsp[j2][i][0]*lhsp[j][i][3];
lhsp[j2][i][2] = lhsp[j2][i][2] - lhsp[j2][i][0]*lhsp[j][i][4];
rhs[k][j2][i][m] = rhs[k][j2][i][m] - lhsp[j2][i][0]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[j][i][2];
lhsm[j][i][3] = fac1*lhsm[j][i][3];
lhsm[j][i][4] = fac1*lhsm[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[j1][i][2] = lhsm[j1][i][2] - lhsm[j1][i][1]*lhsm[j][i][3];
lhsm[j1][i][3] = lhsm[j1][i][3] - lhsm[j1][i][1]*lhsm[j][i][4];
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhsm[j1][i][1]*rhs[k][j][i][m];
lhsm[j2][i][1] = lhsm[j2][i][1] - lhsm[j2][i][0]*lhsm[j][i][3];
lhsm[j2][i][2] = lhsm[j2][i][2] - lhsm[j2][i][0]*lhsm[j][i][4];
rhs[k][j2][i][m] = rhs[k][j2][i][m] - lhsm[j2][i][0]*rhs[k][j][i][m];
}
}
//---------------------------------------------------------------------
// And again the last two rows separately
//---------------------------------------------------------------------
j = grid_points[1]-2;
j1 = grid_points[1]-1;
for (i = 1; i <= grid_points[0]-2; i++) {
m = 3;
fac1 = 1.0/lhsp[j][i][2];
lhsp[j][i][3] = fac1*lhsp[j][i][3];
lhsp[j][i][4] = fac1*lhsp[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsp[j1][i][2] = lhsp[j1][i][2] - lhsp[j1][i][1]*lhsp[j][i][3];
lhsp[j1][i][3] = lhsp[j1][i][3] - lhsp[j1][i][1]*lhsp[j][i][4];
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhsp[j1][i][1]*rhs[k][j][i][m];
m = 4;
fac1 = 1.0/lhsm[j][i][2];
lhsm[j][i][3] = fac1*lhsm[j][i][3];
lhsm[j][i][4] = fac1*lhsm[j][i][4];
rhs[k][j][i][m] = fac1*rhs[k][j][i][m];
lhsm[j1][i][2] = lhsm[j1][i][2] - lhsm[j1][i][1]*lhsm[j][i][3];
lhsm[j1][i][3] = lhsm[j1][i][3] - lhsm[j1][i][1]*lhsm[j][i][4];
rhs[k][j1][i][m] = rhs[k][j1][i][m] - lhsm[j1][i][1]*rhs[k][j][i][m];
//---------------------------------------------------------------------
// Scale the last row immediately
//---------------------------------------------------------------------
rhs[k][j1][i][3] = rhs[k][j1][i][3]/lhsp[j1][i][2];
rhs[k][j1][i][4] = rhs[k][j1][i][4]/lhsm[j1][i][2];
}
//---------------------------------------------------------------------
// BACKSUBSTITUTION
//---------------------------------------------------------------------
j = grid_points[1]-2;
j1 = grid_points[1]-1;
for (i = 1; i <= grid_points[0]-2; i++) {
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] - lhs[j][i][3]*rhs[k][j1][i][m];
}
rhs[k][j][i][3] = rhs[k][j][i][3] - lhsp[j][i][3]*rhs[k][j1][i][3];
rhs[k][j][i][4] = rhs[k][j][i][4] - lhsm[j][i][3]*rhs[k][j1][i][4];
}
//---------------------------------------------------------------------
// The first three factors
//---------------------------------------------------------------------
for (j = grid_points[1]-3; j >= 0; j--) {
j1 = j + 1;
j2 = j + 2;
for (i = 1; i <= grid_points[0]-2; i++) {
for (m = 0; m < 3; m++) {
rhs[k][j][i][m] = rhs[k][j][i][m] -
lhs[j][i][3]*rhs[k][j1][i][m] -
lhs[j][i][4]*rhs[k][j2][i][m];
}
//-------------------------------------------------------------------
// And the remaining two
//-------------------------------------------------------------------
rhs[k][j][i][3] = rhs[k][j][i][3] -
lhsp[j][i][3]*rhs[k][j1][i][3] -
lhsp[j][i][4]*rhs[k][j2][i][3];
rhs[k][j][i][4] = rhs[k][j][i][4] -
lhsm[j][i][3]*rhs[k][j1][i][4] -
lhsm[j][i][4]*rhs[k][j2][i][4];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,j1,j2,m, \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,r1,r2) | 100 | (*)[n2][n1])ou;
int i3, i2, i1;
double r1[M], r2[M];
if (timeron) timer_start(T_psinv);
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
for (i1 = 0; i1 < n1; i1++) {
r1[i1] = r[i3][i2-1][i1] + r[i3][i2+1][i1]
+ r[i3-1][i2][i1] + r[i3+1][i2][i1];
r2[i1] = r[i3-1][i2-1][i1] + r[i3-1][i2+1][i1]
+ r[i3+1][i2-1][i1] + r[i3+1][i2+1][i1];
}
for (i1 = 1; i1 < n1-1; i1++) {
u[i3][i2][i1] = u[i3][i2][i1]
+ c[0] * r[i3][i2][i1]
+ c[1] * ( r[i3][i2][i1-1] + r[i3][i2][i1+1]
+ r1[i1] )
+ c[2] * ( r2[i1] + r1[i1-1] + r1[i1+1] );
//--------------------------------------------------------------------
// Assume c[3] = 0 (Enable line below if c[3] not= 0)
//--------------------------------------------------------------------
// + c[3] * ( r2[i1-1] + r2[i1+1] )
//--------------------------------------------------------------------
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3,r1,r2)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,u1,u2) | 100 | e (*)[n2][n1])or;
int i3, i2, i1;
double u1[M], u2[M];
if (timeron) timer_start(T_resid);
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
for (i1 = 0; i1 < n1; i1++) {
u1[i1] = u[i3][i2-1][i1] + u[i3][i2+1][i1]
+ u[i3-1][i2][i1] + u[i3+1][i2][i1];
u2[i1] = u[i3-1][i2-1][i1] + u[i3-1][i2+1][i1]
+ u[i3+1][i2-1][i1] + u[i3+1][i2+1][i1];
}
for (i1 = 1; i1 < n1-1; i1++) {
r[i3][i2][i1] = v[i3][i2][i1]
- a[0] * u[i3][i2][i1]
//-------------------------------------------------------------------
// Assume a[1] = 0 (Enable 2 lines below if a[1] not= 0)
//-------------------------------------------------------------------
// - a[1] * ( u[i3][i2][i1-1] + u[i3][i2][i1+1]
// + u1[i1] )
//-------------------------------------------------------------------
- a[2] * ( u2[i1] + u1[i1-1] + u1[i1+1] )
- a[3] * ( u2[i1-1] + u2[i1+1] );
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3,u1,u2)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) \ | 100 | d2 = 2;
} else {
d2 = 1;
}
if (m3k == 3) {
d3 = 2;
} else {
d3 = 1;
}
<LOOP-START>private(j1,j2,j3,i1,i2,i3,x1,y1,x2,y2)
for (j3 = 1; j3 < m3j-1; j3++) {
i3 = 2*j3-d3;
for (j2 = 1; j2 < m2j-1; j2++) {
i2 = 2*j2-d2;
for (j1 = 1; j1 < m1j; j1++) {
i1 = 2*j1-d1;
x1[i1] = r[i3+1][i2 ][i1] + r[i3+1][i2+2][i1]
+ r[i3 ][i2+1][i1] + r[i3+2][i2+1][i1];
y1[i1] = r[i3 ][i2 ][i1] + r[i3+2][i2 ][i1]
+ r[i3 ][i2+2][i1] + r[i3+2][i2+2][i1];
}
for (j1 = 1; j1 < m1j-1; j1++) {
i1 = 2*j1-d1;
y2 = r[i3 ][i2 ][i1+1] + r[i3+2][i2 ][i1+1]
+ r[i3 ][i2+2][i1+1] + r[i3+2][i2+2][i1+1];
x2 = r[i3+1][i2 ][i1+1] + r[i3+1][i2+2][i1+1]
+ r[i3 ][i2+1][i1+1] + r[i3+2][i2+1][i1+1];
s[j3][j2][j1] =
0.5 * r[i3+1][i2+1][i1+1]
+ 0.25 * (r[i3+1][i2+1][i1] + r[i3+1][i2+1][i1+2] + x2)
+ 0.125 * (x1[i1] + x1[i1+2] + y2)
+ 0.0625 * (y1[i1] + y1[i1+2]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3,z1,z2,z3) | 100 | M], z2[M], z3[M];
if (timeron) timer_start(T_interp);
if (n1 != 3 && n2 != 3 && n3 != 3) {
<LOOP-START>for (i3 = 0; i3 < mm3-1; i3++) {
for (i2 = 0; i2 < mm2-1; i2++) {
for (i1 = 0; i1 < mm1; i1++) {
z1[i1] = z[i3][i2+1][i1] + z[i3][i2][i1];
z2[i1] = z[i3+1][i2][i1] + z[i3][i2][i1];
z3[i1] = z[i3+1][i2+1][i1] + z[i3+1][i2][i1] + z1[i1];
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3][2*i2][2*i1] = u[2*i3][2*i2][2*i1]
+ z[i3][i2][i1];
u[2*i3][2*i2][2*i1+1] = u[2*i3][2*i2][2*i1+1]
+ 0.5 * (z[i3][i2][i1+1] + z[i3][i2][i1]);
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3][2*i2+1][2*i1] = u[2*i3][2*i2+1][2*i1]
+ 0.5 * z1[i1];
u[2*i3][2*i2+1][2*i1+1] = u[2*i3][2*i2+1][2*i1+1]
+ 0.25 * (z1[i1] + z1[i1+1]);
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3+1][2*i2][2*i1] = u[2*i3+1][2*i2][2*i1]
+ 0.5 * z2[i1];
u[2*i3+1][2*i2][2*i1+1] = u[2*i3+1][2*i2][2*i1+1]
+ 0.25 * (z2[i1] + z2[i1+1]);
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3+1][2*i2+1][2*i1] = u[2*i3+1][2*i2+1][2*i1]
+ 0.25 * z3[i1];
u[2*i3+1][2*i2+1][2*i1+1] = u[2*i3+1][2*i2+1][2*i1+1]
+ 0.125 * (z3[i1] + z3[i1+1]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3,z1,z2,z3)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i2,i3,x1,xx,rdummy) \ | 100 | -------
// fill array
//---------------------------------------------------------------------
<LOOP-START>shared(e2,e3,d1,a1)
for (i3 = 1; i3 < e3; i3++) {
x1 = starts[i3];
for (i2 = 1; i2 < e2; i2++) {
xx = x1;
vranlc(d1, &xx, a, &(z[i3][i2][1]));
rdummy = randlc(&x1, a1);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i2,i3,x1,xx,rdummy) \<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3) | 100 | i >= 0; i--) {
printf(" %4d", jg[0][i][1]);
if (++cnt % 10 == 0) printf("\n");
}
*/
<LOOP-START>for (i3 = 0; i3 < n3; i3++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/MG/mg.c | #pragma omp parallel for default(shared) private(i1,i2,i3) | 100 | oz, int n1, int n2, int n3)
{
double (*z)[n2][n1] = (double (*)[n2][n1])oz;
int i1, i2, i3;
<LOOP-START>for (i3 = 0; i3 < n3; i3++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/IS/is.c | #pragma omp parallel for | 100 | ; i++) {
bucket_size[i] = (INT_TYPE *)alloc_mem(sizeof(INT_TYPE) * NUM_BUCKETS);
}
<LOOP-START>for( i=0; i<NUM_KEYS; i++ )
key_buff2[i] = 0;
#else /*USE_BUCKETS*/
key_buff1_aptr = (INT_TYPE **)alloc_mem(sizeof(INT_TYPE *) * num_procs);
key_buff1_aptr[0] = key_buff1;
for (i = 1; i < num_procs; i++) {
key_buff1_aptr[i] = (INT_TYPE *)alloc_mem(sizeof(INT_TYPE) * MAX_KEY);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/IS/is.c | #pragma omp parallel for private(i,j,k,k1) schedule(static,1) | 100 | ETS
/* Buckets are already sorted. Sorting keys within each bucket */
#ifdef SCHED_CYCLIC
<LOOP-START>#else
#pragma omp parallel for private(i,j,k,k1) schedule(dynamic)
for( j=0; j< NUM_BUCKETS; j++ ) {
k1 = (j > 0)? bucket_ptrs[j-1] : 0;
for ( i = k1; i < bucket_ptrs[j]; i++ ) {
k = --key_buff_ptr_global[key_buff2[i]];
key_array[k] = key_buff2[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k,k1) schedule(static,1)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/IS/is.c | #pragma omp parallel for private(i,j,k,k1) schedule(dynamic) | 100 | */
#ifdef SCHED_CYCLIC
#pragma omp parallel for private(i,j,k,k1) schedule(static,1)
#else
<LOOP-START>for( j=0; j< NUM_BUCKETS; j++ ) {
k1 = (j > 0)? bucket_ptrs[j-1] : 0;
for ( i = k1; i < bucket_ptrs[j]; i++ ) {
k = --key_buff_ptr_global[key_buff2[i]];
key_array[k] = key_buff2[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k,k1) schedule(dynamic)<OMP-END> |
OpenACCUserGroup/openacc-users-group/Contributed_Sample_Codes/NAS_SHOC_OpenACC_2.5/NPB-OMP-C/IS/is.c | #pragma omp parallel for reduction(+:j) | 100 | endif
/* Confirm keys correctly sorted: count incorrectly sorted keys, if any */
j = 0;
<LOOP-START>for( i=1; i<NUM_KEYS; i++ )
if( key_array[i-1] > key_array[i] )
j++;
if( j != 0 )
printf( "Full_verify: number of keys out of sort: %ld\n", (long)j );
else
passed_verification++;
}
/*****************************************************************/
/************* R A N K ****************/
/*****************************************************************/
void rank( int iteration )
{
INT_TYPE i, k;
INT_TYPE *key_buff_ptr, *key_buff_ptr2;
#ifdef USE_BUCKETS
int shift = MAX_KEY_LOG_2 - NUM_BUCKETS_LOG_2;
INT_TYPE num_bucket_keys = (1L << shift);
key_array[iteration] = iteration;
key_array[iteration+MAX_ITERATIONS] = MAX_KEY - iteration;
/* Determine where the partial verify test keys are, load into */
/* top of array bucket_size */
for( i=0; i<TEST_ARRAY_SIZE; i++ )
partial_verify_vals[i] = key_array[test_index_array[i]];
/* Setup pointers to key buffers */
#ifdef USE_BUCKETS
key_buff_ptr2 = key_buff2;
#else
key_buff_ptr2 = key_array;
key_buff_ptr = key_buff1;
#pragma omp parallel private(i, k)
{
INT_TYPE *work_buff, m, k1, k2;
int myid = 0, num_procs = 1;
#ifdef _OPENMP
myid = omp_get_thread_num();
num_procs = omp_get_num_threads();
/* Bucket sort is known to improve cache performance on some */
/* cache based systems. But the actual performance may depend */
/* on cache size, problem size. */
#ifdef USE_BUCKETS
work_buff = bucket_size[myid];
/* Initialize */
for( i=0; i<NUM_BUCKETS; i++ )
work_buff[i] = 0;
/* Determine the number of keys in each bucket */
#pragma omp for schedule(static)
for( i=0; i<NUM_KEYS; i++ )
work_buff[key_array[i] >> shift]++;
/* Accumulative bucket sizes are the bucket pointers.
These are global sizes accumulated upon to each bucket */
bucket_ptrs[0] = 0;
for( k=0; k< myid; k++ )
bucket_ptrs[0] += bucket_size[k][0];
for( i=1; i< NUM_BUCKETS; i++ ) {
bucket_ptrs[i] = bucket_ptrs[i-1];
for( k=0; k< myid; k++ )
bucket_ptrs[i] += bucket_size[k][i];
for( k=myid; k< num_procs; k++ )
bucket_ptrs[i] += bucket_size[k][i-1];
}
/* Sort into appropriate bucket */
#pragma omp for schedule(static)
for( i=0; i<NUM_KEYS; i++ )
{
k = key_array[i];
key_buff2[bucket_ptrs[k >> shift]++] = k;
}
/* The bucket pointers now point to the final accumulated sizes */
if (myid < num_procs-1) {
for( i=0; i< NUM_BUCKETS; i++ )
for( k=myid+1; k< num_procs; k++ )
bucket_ptrs[i] += bucket_size[k][i];
}
/* Now, buckets are sorted. We only need to sort keys inside
each bucket, which can be done in parallel. Because the distribution
of the number of keys in the buckets is Gaussian, the use of
a dynamic schedule should improve load balance, thus, performance */
#ifdef SCHED_CYCLIC
#pragma omp for schedule(static,1)
#else
#pragma omp for schedule(dynamic)
for( i=0; i< NUM_BUCKETS; i++ ) {
/* Clear the work array section associated with each bucket */
k1 = i * num_bucket_keys;
k2 = k1 + num_bucket_keys;
for ( k = k1; k < k2; k++ )
key_buff_ptr[k] = 0;
/* Ranking of all keys occurs in this section: */
/* In this section, the keys themselves are used as their
own indexes to determine how many of each there are: their
individual population */
m = (i > 0)? bucket_ptrs[i-1] : 0;
for ( k = m; k < bucket_ptrs[i]; k++ )
key_buff_ptr[key_buff_ptr2[k]]++; /* Now they have individual key */
/* population */
/* To obtain ranks of each key, successively add the individual key
population, not forgetting to add m, the total of lesser keys,
to the first key population */
key_buff_ptr[k1] += m;
for ( k = k1+1; k < k2; k++ )
key_buff_ptr[k] += key_buff_ptr[k-1];
}
#else /*USE_BUCKETS*/
work_buff = key_buff1_aptr[myid];
/* Clear the work array */
for( i=0; i<MAX_KEY; i++ )
work_buff[i] = 0;
/* Ranking of all keys occurs in this section: */
/* In this section, the keys themselves are used as their
own indexes to determine how many of each there are: their
individual population */
#pragma omp for nowait schedule(static)
for( i=0; i<NUM_KEYS; i++ )
work_buff[key_buff_ptr2[i]]++; /* Now they have individual key */
/* population */
/* To obtain ranks of each key, successively add the individual key
population */
for( i=0; i<MAX_KEY-1; i++ )
work_buff[i+1] += work_buff[i];
#pragma omp barrier
/* Accumulate the global key population */
for( k=1; k<num_procs; k++ ) {
#pragma omp for nowait schedule(static)
for( i=0; i<MAX_KEY; i++ )
key_buff_ptr[i] += key_buff1_aptr[k][i];
}
/*USE_BUCKETS*/
} /*omp parallel*/
/* This is the partial verify test section */
/* Observe that test_rank_array vals are */
/* shifted differently for different cases */
for( i=0; i<TEST_ARRAY_SIZE; i++ )
{
k = partial_verify_vals[i]; /* test vals were put here */
if( 0 < k && k <= NUM_KEYS-1 )
{
INT_TYPE key_rank = key_buff_ptr[k-1];
int failed = 0;
switch( CLASS )
{
case 'S':
if( i <= 2 )
{
if( key_rank != test_rank_array[i]+iteration )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-iteration )
failed = 1;
else
passed_verification++;
}
break;
case 'W':
if( i < 2 )
{
if( key_rank != test_rank_array[i]+(iteration-2) )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-iteration )
failed = 1;
else
passed_verification++;
}
break;
case 'A':
if( i <= 2 )
{
if( key_rank != test_rank_array[i]+(iteration-1) )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-(iteration-1) )
failed = 1;
else
passed_verification++;
}
break;
case 'B':
if( i == 1 || i == 2 || i == 4 )
{
if( key_rank != test_rank_array[i]+iteration )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-iteration )
failed = 1;
else
passed_verification++;
}
break;
case 'C':
if( i <= 2 )
{
if( key_rank != test_rank_array[i]+iteration )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-iteration )
failed = 1;
else
passed_verification++;
}
break;
case 'D':
if( i < 2 )
{
if( key_rank != test_rank_array[i]+iteration )
failed = 1;
else
passed_verification++;
}
else
{
if( key_rank != test_rank_array[i]-iteration )
failed = 1;
else
passed_verification++;
}
break;
}
if( failed == 1 )
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, (int)i );
}
}
/* Make copies of rank info for use by full_verify: these variables
in rank are local; making them global slows down the code, probably
since they cannot be made register by compiler */
if( iteration == MAX_ITERATIONS )
key_buff_ptr_global = key_buff_ptr;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:j)<OMP-END> |
KarypisLab/TriangleCounting/ptc.c | #pragma omp parallel for schedule(static,4096) default(none) \ | 100 | oc(nvtxs, "iperm"); /* iperm[new-vtx-num] => old-vtx-num */
/* Determine maxdegree/csrange */
<LOOP-START>shared(nvtxs, xadj) \
reduction(max: maxdegree)
for (vi=0; vi<nvtxs; vi++)
maxdegree = gk_max(maxdegree, (int32_t)(xadj[vi+1]-xadj[vi]));
csrange = maxdegree+1;
csrange = 16*((csrange+15)/16); /* get the per thread arrays to be alligned
at the start of the cache line */
gcounts = gk_i32malloc(nthreads*csrange, "gcounts");
psums = gk_zmalloc(nthreads, "psums");
#pragma omp parallel default(none) \
shared(vault, nvtxs, nthreads, maxdegree, csrange, xadj, adjncy, nxadj, nadjncy, \
perm, iperm, gcounts, psums, chunkptr, stdout)
{
int32_t vi, vistart, viend, vj, nedges, nchunks;
int32_t ti, di, ci, dstart, dend;
int32_t *counts, *buffer;
ssize_t ej, ejend, psum, chunksize;
#if defined(_OPENMP)
int mytid = omp_get_thread_num();
#else
int mytid = 0;
vistart = mytid*((nvtxs+nthreads-1)/nthreads);
viend = gk_min(nvtxs, (mytid+1)*((nvtxs+nthreads-1)/nthreads));
dstart = mytid*((csrange+nthreads-1)/nthreads);
dend = gk_min(csrange, (mytid+1)*((csrange+nthreads-1)/nthreads));
/* Compute the local counts */
counts = gcounts + mytid*csrange;
gk_i32set(csrange, 0, counts);
for (vi=vistart; vi<viend; vi++)
counts[xadj[vi+1]-xadj[vi]]++;
#pragma omp barrier
/* Compute the partial sum of the range assigned to each thread */
for (psum=0, ti=0; ti<nthreads; ti++) {
counts = gcounts + ti*csrange;
for (di=dstart; di<dend; di++)
psum += counts[di];
}
psums[mytid] = psum;
#pragma omp barrier
#pragma omp single
for (ti=1; ti<nthreads; ti++)
psums[ti] += psums[ti-1];
#pragma omp barrier
/* Compute the actual prefix sums of the range assigned to each thread.
This is done from right to left to get it into the desired exclusive
prefix sum stage. */
psum = psums[mytid];
for (di=dend-1; di>=dstart; di--) {
counts = gcounts + (nthreads-1)*csrange;
for (ti=nthreads-1; ti>=0; ti--) {
psum -= counts[di];
counts[di] = psum;
counts -= csrange;
}
}
#pragma omp barrier
/* Create the perm/iperm arrays and the nxadj array of the re-ordered graph */
counts = gcounts + mytid*csrange;
/* TODO: This can be optimized by pre-sorting the per-thread vertices according
to their degree and processing them in increasing degree order */
for (vi=vistart; vi<viend; vi++) {
perm[vi] = counts[xadj[vi+1]-xadj[vi]]++;
nxadj[perm[vi]] = xadj[vi+1]-xadj[vi]+1; /* the +1 is for the diagonal */
iperm[perm[vi]] = vi;
}
#pragma omp barrier
#pragma omp barrier
/* compute the local sums and their prefix sums */
for (psum=0, vi=vistart; vi<viend; vi++)
psum += nxadj[vi];
psums[mytid] = psum;
#pragma omp barrier
#pragma omp single
for (ti=1; ti<nthreads; ti++)
psums[ti] += psums[ti-1];
#pragma omp barrier
/* Compute the actual prefix sums of the nxadj[] array assigned to each thread.
This is done from right to left to get it into the desired exclusive
prefix sum stage. */
psum = psums[mytid];
if (mytid == nthreads-1)
nxadj[nvtxs] = psum;
for (vi=viend-1; vi>=vistart; vi--) {
psum -= nxadj[vi];
nxadj[vi] = psum;
}
#pragma omp barrier
/* Compute the chunk-based partitioning of the work for the reordered/sorted graph */
chunksize = 1+psums[nthreads-1]/(100*nthreads);
for (nchunks=0, psum=0, vi=vistart; vi<viend; vi++) {
if ((psum += nxadj[vi+1]-nxadj[vi]) >= chunksize) {
nchunks++;
psum = 0;
}
}
psums[mytid] = nchunks+1;
#pragma omp barrier
#pragma omp single
for (ti=1; ti<nthreads; ti++)
psums[ti] += psums[ti-1];
#pragma omp barrier
#pragma omp single
chunkptr = gk_i32malloc(psums[nthreads-1]+1, "chunkptr");
#pragma omp barrier
nchunks = psums[mytid];
chunkptr[nchunks] = viend;
for (psum=0, vi=viend-1; vi>=vistart; vi--) {
if ((psum += nxadj[vi+1]-nxadj[vi]) >= chunksize) {
chunkptr[--nchunks] = vi;
psum = 0;
}
}
if (mytid == 0)
chunkptr[0] = 0;
#pragma omp barrier
nchunks = psums[nthreads-1]; /* this is the total # of chunks */
/*
#pragma omp single
{
for (vi=0; vi<nchunks; vi++) {
printf("%4d: %6d - %6d [%5d: %zd]\n", vi, chunkptr[vi], chunkptr[vi+1],
chunkptr[vi+1]-chunkptr[vi], nxadj[chunkptr[vi+1]]-nxadj[chunkptr[vi]]);
}
}
#pragma omp barrier
*/
/* create the reordered/sorted graph by processing the chunks in parallel */
#pragma omp for schedule(dynamic, 1) nowait
for (ci=nchunks-1; ci>=0; ci--) {
for (vi=chunkptr[ci]; vi<chunkptr[ci+1]; vi++) {
vj = iperm[vi];
buffer = nadjncy+nxadj[vi];
for (nedges=0, ej=xadj[vj], ejend=xadj[vj+1]; ej<ejend; ej++, nedges++)
buffer[nedges] = perm[adjncy[ej]];
buffer[nedges++] = vi; /* put the diagonal */
if (nedges > 1)
gk_i32sorti(nedges, buffer); /* sort adjncy list */
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static,4096) default(none) \<OMP-END> |
KarypisLab/TriangleCounting/ptc.c | #pragma omp parallel for schedule(dynamic,1024) \ | 100 | lt->timer_tc);
/* populate uxadj[] and determine the size of the hash-map */
startv = nvtxs;
<LOOP-START>default(none) \
shared(nvtxs, xadj, adjncy, uxadj) \
private(vj, ei, ej) \
reduction(max: maxhmsize) \
reduction(min: startv)
for (vi=nvtxs-1; vi>=0; vi--) {
for (ei=xadj[vi+1]-1; adjncy[ei]>vi; ei--);
uxadj[vi] = ei;
maxhmsize = gk_max(maxhmsize, (int32_t)(xadj[vi+1]-uxadj[vi]));
startv = (uxadj[vi] != xadj[vi] ? vi : startv);
/* flip the order of Adj(vi)'s upper triangular adjacency list */
for (ej=xadj[vi+1]-1; ei<ej; ei++, ej--) {
vj = adjncy[ei];
adjncy[ei] = adjncy[ej];
adjncy[ej] = vj;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1024) \<OMP-END> |
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) reduction(max: max_val) | 100 | t const * const restrict array,
int64_t N)
{
assert(N > 0);
int32_t max_val = array[0];
<LOOP-START>for(int64_t i=0; i < N; ++i) {
max_val = gk_max(max_val, array[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(max: max_val)<OMP-END> |
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) reduction(max: degree) | 100 | n max_val;
}
ssize_t graph_max_degree(
gk_graph_t const * const G)
{
ssize_t degree = 0;
<LOOP-START>for(int32_t v=0; v < G->nvtxs; ++v) {
degree = gk_max(degree, G->xadj[v+1] - G->xadj[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(max: degree)<OMP-END> |
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) | 100 | T->adjncy");
/* get counts for xadj */
par_memset(T->xadj, 0, (nvtxs+1) * sizeof(*T->xadj));
<LOOP-START>for(int64_t e=0; e < nedges; ++e) {
#pragma omp atomic
T->xadj[G->adjncy[e]]++;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.