filename
stringlengths 78
241
| omp_pragma_line
stringlengths 24
416
| context_chars
int64 100
100
| text
stringlengths 152
177k
|
|---|---|---|---|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
-----*/
j = grid_points[1]-2;
j1 = grid_points[1]-1;
n = 0;
for (m = 0; m < 3; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
| 100
|
0; m < 3; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
| 100
|
{
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}
}
}
<LOOP-START>for (m = 3; m < 5; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
for (k = 1; k <= grid_points[2]-2; k++) {
n = (m-3+1)*5;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
}
}
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
for (m = 3; m < 5; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
for (k = 1; k <= grid_points[2]-2; k++) {
n = (m-3+1)*5;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
| 100
|
3; m < 5; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
n = (m-3+1)*5;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m )
| 100
|
rst three factors
--------------------------------------------------------------------*/
n = 0;
<LOOP-START>for (m = 0; m < 3; m++) {
for (j = grid_points[1]-3; j >= 0; j--) {
j1 = j + 1;
j2 = j + 2;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m )
for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k] -
lhs[n+4][i][j][k]*rhs[m][i][j2][k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,k ,j1 ,j ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
3; m++) {
for (j = grid_points[1]-3; j >= 0; j--) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m )
for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k] -
lhs[n+4][i][j][k]*rhs[m][i][j2][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,m )
| 100
|
j2 = j + 2;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k] -
lhs[n+4][i][j][k]*rhs[m][i][j2][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(j ,i ,j2 ,k ,m ,n )
| 100
|
And the remaining two
--------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
for (j = grid_points[1]-3; j >= 0; j--) {
j1 = j + 1;
j2 = j1 + 1;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k] -
lhs[n+4][i][j][k]*rhs[m][i][j2][k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(j ,i ,j2 ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
m-3+1)*5;
for (j = grid_points[1]-3; j >= 0; j--) {
j1 = j + 1;
j2 = j1 + 1;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j1][k] -
lhs[n+4][i][j][k]*rhs[m][i][j2][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
ON
c-------------------------------------------------------------------*/
lhsz();
n = 0;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(m ,j ,k ,fac1 ,i )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
}
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
}
lhs[n+1][i][j][k2] = lhs[n+1][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+3][i][j][k];
lhs[n+2][i][j][k2] = lhs[n+2][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k2] = rhs[m][i][j][k2] -
lhs[n+0][i][j][k2]*rhs[m][i][j][k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(m ,j ,k ,fac1 ,i )
| 100
|
/
lhsz();
n = 0;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
}
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
}
lhs[n+1][i][j][k2] = lhs[n+1][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+3][i][j][k];
lhs[n+2][i][j][k2] = lhs[n+2][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k2] = rhs[m][i][j][k2] -
lhs[n+0][i][j][k2]*rhs[m][i][j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(m ,j ,k ,fac1 ,i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
---------------------------------------------*/
k = grid_points[2]-2;
k1 = grid_points[2]-1;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(m ,j ,fac1 ,fac2 ,k ,k1 ,i )
for (j = 1; j <= grid_points[1]-2; j++) {
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
}
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
}
/*--------------------------------------------------------------------
c scale the last row immediately
c-------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j][k1];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = fac2*rhs[m][i][j][k1];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(m ,j ,fac1 ,fac2 ,k ,k1 ,i )
| 100
|
k1 = grid_points[2]-1;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
}
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
}
/*--------------------------------------------------------------------
c scale the last row immediately
c-------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j][k1];
for (m = 0; m < 3; m++) {
rhs[m][i][j][k1] = fac2*rhs[m][i][j][k1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(m ,j ,fac1 ,fac2 ,k ,k1 ,i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n )
| 100
|
u-c factors
c-------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
lhs[n+1][i][j][k2] = lhs[n+1][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+3][i][j][k];
lhs[n+2][i][j][k2] = lhs[n+2][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+4][i][j][k];
rhs[m][i][j][k2] = rhs[m][i][j][k2] -
lhs[n+0][i][j][k2]*rhs[m][i][j][k];
}
}
}
/*--------------------------------------------------------------------
c And again the last two rows separately
c-------------------------------------------------------------------*/
k = grid_points[2]-2;
k1 = grid_points[2]-1;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately (some of this is overkill
c if this is the last cell)
c-------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j][k1];
rhs[m][i][j][k1] = fac2*rhs[m][i][j][k1];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
llel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n )
for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
lhs[n+1][i][j][k2] = lhs[n+1][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+3][i][j][k];
lhs[n+2][i][j][k2] = lhs[n+2][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+4][i][j][k];
rhs[m][i][j][k2] = rhs[m][i][j][k2] -
lhs[n+0][i][j][k2]*rhs[m][i][j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n )
| 100
|
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 0; k <= grid_points[2]-3; k++) {
k1 = k + 1;
k2 = k + 2;
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
lhs[n+1][i][j][k2] = lhs[n+1][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+3][i][j][k];
lhs[n+2][i][j][k2] = lhs[n+2][i][j][k2] -
lhs[n+0][i][j][k2]*lhs[n+4][i][j][k];
rhs[m][i][j][k2] = rhs[m][i][j][k2] -
lhs[n+0][i][j][k2]*rhs[m][i][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,fac1 ,k1 ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
---------------------------------------*/
k = grid_points[2]-2;
k1 = grid_points[2]-1;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
fac1 = 1./lhs[n+2][i][j][k];
lhs[n+3][i][j][k] = fac1*lhs[n+3][i][j][k];
lhs[n+4][i][j][k] = fac1*lhs[n+4][i][j][k];
rhs[m][i][j][k] = fac1*rhs[m][i][j][k];
lhs[n+2][i][j][k1] = lhs[n+2][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+3][i][j][k];
lhs[n+3][i][j][k1] = lhs[n+3][i][j][k1] -
lhs[n+1][i][j][k1]*lhs[n+4][i][j][k];
rhs[m][i][j][k1] = rhs[m][i][j][k1] -
lhs[n+1][i][j][k1]*rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately (some of this is overkill
c if this is the last cell)
c-------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j][k1];
rhs[m][i][j][k1] = fac2*rhs[m][i][j][k1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
-----*/
k = grid_points[2]-2;
k1 = grid_points[2]-1;
n = 0;
for (m = 0; m < 3; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m )
for (j = 1; j <= grid_points[1]-2; j++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m )
| 100
|
0; m < 3; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
| 100
|
{
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}
}
}
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
p parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
| 100
|
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
| 100
|
rst three factors
c-------------------------------------------------------------------*/
n = 0;
<LOOP-START>for (m = 0; m < 3; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
n = 0;
#pragma omp parallel for firstprivate(i ,j ,k1 ,k ,m ,n )
for (m = 0; m < 3; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,m )
| 100
|
0; m < 3; m++) {
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,m ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,m ,n )
| 100
|
And the remaining two
c-------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for
| 100
|
a omp parallel for firstprivate(i ,j ,k ,m ,n )
for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for firstprivate(i ,j ,k ,m ,n )
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for firstprivate(i ,j ,k ,m ,n )
| 100
|
n = (m-3+1)*5;
#pragma omp parallel for
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
for (k = grid_points[2]-3; k >= 0; k--) {
k1 = k + 1;
k2 = k + 2;
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i][j][k1] -
lhs[n+4][i][j][k]*rhs[m][i][j][k2];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ,j ,k ,m ,n ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for firstprivate(j )
| 100
|
uctured OpenMP C version"
" - EP Benchmark\n");
sprintf(size, "%12.0f", pow(2.0, M+1));
<LOOP-START>for (j = 13; j >= 1; j--) {
if (size[j] == '.') size[j] = ' ';
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(j ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for private(i )
| 100
|
e.
*/
vranlc(0, &(dum[0]), dum[1], &(dum[2]));
dum[0] = randlc(&(dum[1]), dum[2]);
<LOOP-START>for (i = 0; i < 2*NK; i++) x[i] = -1.0e99;
Mops = log(sqrt(fabs(max(1.0, 1.0))));
timer_clear(1);
timer_clear(2);
timer_clear(3);
timer_start(1);
vranlc(0, &t1, A, x);
/* Compute AN = A ^ (2 * NK) (mod 2^46). */
t1 = A;
for ( i = 1; i <= MK+1; i++) {
t2 = randlc(&t1, t1);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
2 = randlc(&t1, t1);
}
an = t1;
tt = S;
gc = 0.0;
sx = 0.0;
sy = 0.0;
<LOOP-START>for ( i = 0; i <= NQ - 1; i++) {
q[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
t2, t3, t4, x1, x2;
int kk, i, ik, l;
double qq[NQ]; /* private copy of q[0:NQ-1] */
<LOOP-START>for (i = 0; i < NQ; i++) qq[i] = 0.0;
#pragma omp parallel for reduction(+:sx) reduction(+:sy)
for (k = 1; k <= np; k++) {
kk = k_offset + k;
t1 = S;
t2 = an;
/* Find starting seed t1 for this kk. */
for (i = 1; i <= 100; i++) {
ik = kk / 2;
if (2 * ik != kk) t3 = randlc(&t1, t2);
if (ik == 0) break;
t3 = randlc(&t2, t2);
kk = ik;
}
/* Compute uniform pseudorandom numbers. */
if (TIMERS_ENABLED == TRUE) timer_start(3);
vranlc(2*NK, &t1, A, x-1);
if (TIMERS_ENABLED == TRUE) timer_stop(3);
/*
c Compute Gaussian deviates by acceptance-rejection method and
c tally counts in concentric square annuli. This loop is not
c vectorizable.
*/
if (TIMERS_ENABLED == TRUE) timer_start(2);
for ( i = 0; i < NK; i++) {
x1 = 2.0 * x[2*i] - 1.0;
x2 = 2.0 * x[2*i+1] - 1.0;
t1 = pow2(x1) + pow2(x2);
if (t1 <= 1.0) {
t2 = sqrt(-2.0 * log(t1) / t1);
t3 = (x1 * t2); /* Xi */
t4 = (x2 * t2); /* Yi */
l = max(fabs(t3), fabs(t4));
qq[l] += 1.0; /* counts */
sx = sx + t3; /* sum of Xi */
sy = sy + t4; /* sum of Yi */
}
}
if (TIMERS_ENABLED == TRUE) timer_stop(2);
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for reduction(+:sx) reduction(+:sy)
| 100
|
] */
#pragma omp parallel for firstprivate(i )
for (i = 0; i < NQ; i++) qq[i] = 0.0;
<LOOP-START>for (k = 1; k <= np; k++) {
kk = k_offset + k;
t1 = S;
t2 = an;
/* Find starting seed t1 for this kk. */
for (i = 1; i <= 100; i++) {
ik = kk / 2;
if (2 * ik != kk) t3 = randlc(&t1, t2);
if (ik == 0) break;
t3 = randlc(&t2, t2);
kk = ik;
}
/* Compute uniform pseudorandom numbers. */
if (TIMERS_ENABLED == TRUE) timer_start(3);
vranlc(2*NK, &t1, A, x-1);
if (TIMERS_ENABLED == TRUE) timer_stop(3);
/*
c Compute Gaussian deviates by acceptance-rejection method and
c tally counts in concentric square annuli. This loop is not
c vectorizable.
*/
if (TIMERS_ENABLED == TRUE) timer_start(2);
for ( i = 0; i < NK; i++) {
x1 = 2.0 * x[2*i] - 1.0;
x2 = 2.0 * x[2*i+1] - 1.0;
t1 = pow2(x1) + pow2(x2);
if (t1 <= 1.0) {
t2 = sqrt(-2.0 * log(t1) / t1);
t3 = (x1 * t2); /* Xi */
t4 = (x2 * t2); /* Yi */
l = max(fabs(t3), fabs(t4));
qq[l] += 1.0; /* counts */
sx = sx + t3; /* sum of Xi */
sy = sy + t4; /* sum of Yi */
}
}
if (TIMERS_ENABLED == TRUE) timer_stop(2);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sx) reduction(+:sy) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
; /* sum of Yi */
}
}
if (TIMERS_ENABLED == TRUE) timer_stop(2);
}
{
<LOOP-START>for (i = 0; i <= NQ - 1; i++) q[i] += qq[i];
}
#if defined(_OPENMP)
nthreads = omp_get_num_threads();
/* _OPENMP */
} /* end of parallel region */
#pragma omp parallel for firstprivate(i ) reduction(+:gc)
for (i = 0; i <= NQ-1; i++) {
gc = gc + q[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for firstprivate(i ) reduction(+:gc)
| 100
|
nthreads = omp_get_num_threads();
#endif /* _OPENMP */
} /* end of parallel region */
<LOOP-START>for (i = 0; i <= NQ-1; i++) {
gc = gc + q[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) reduction(+:gc) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
LT_DEFAULT;
nit = NIT_DEFAULT;
nx[lt] = NX_DEFAULT;
ny[lt] = NY_DEFAULT;
nz[lt] = NZ_DEFAULT;
<LOOP-START>for (i = 0; i <= 7; i++) {
debug_vec[i] = DEBUG_DEFAULT;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(lt ,k )
| 100
|
r ( k = lt-1; k >= 1; k--) {
nx[k] = nx[k+1]/2;
ny[k] = ny[k+1]/2;
nz[k] = nz[k+1]/2;
}
<LOOP-START>for (k = 1; k <= lt; k++) {
m1[k] = nx[k]+2;
m2[k] = nz[k]+2;
m3[k] = ny[k]+2;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(lt ,k ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 ,r1 ,r2 )
| 100
|
-----------------------------------------------*/
int i3, i2, i1;
double r1[M], r2[M];
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
#pragma omp parallel for firstprivate(n1 ,r ,i1 ,i2 ,i3 )
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];
}
#pragma omp parallel for firstprivate(n1 ,c ,r ,u ,i1 ,i2 ,i3 )
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] );
/*--------------------------------------------------------------------
c Assume c(3) = 0 (Enable line below if c(3) not= 0)
c---------------------------------------------------------------------
c > + c(3) * ( r2(i1-1) + r2(i1+1) )
c-------------------------------------------------------------------*/
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ,r1 ,r2 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n1 ,r ,i1 ,i2 ,i3 )
| 100
|
,i2 ,i3 ,r1 ,r2 )
for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
<LOOP-START>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];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n1 ,r ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n1 ,c ,r ,u ,i1 ,i2 ,i3 )
| 100
|
-1][i2-1][i1] + r[i3-1][i2+1][i1]
+ r[i3+1][i2-1][i1] + r[i3+1][i2+1][i1];
}
<LOOP-START>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] );
/*--------------------------------------------------------------------
c Assume c(3) = 0 (Enable line below if c(3) not= 0)
c---------------------------------------------------------------------
c > + c(3) * ( r2(i1-1) + r2(i1+1) )
c-------------------------------------------------------------------*/
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n1 ,c ,r ,u ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 ,u1 ,u2 )
| 100
|
-----------------------------------------------*/
int i3, i2, i1;
double u1[M], u2[M];
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
#pragma omp parallel for firstprivate(n1 ,u ,i1 ,i2 ,i3 )
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]
/*--------------------------------------------------------------------
c Assume a(1) = 0 (Enable 2 lines below if a(1) not= 0)
c---------------------------------------------------------------------
c > - a(1) * ( u(i1-1,i2,i3) + u(i1+1,i2,i3)
c > + u1(i1) )
c-------------------------------------------------------------------*/
- 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 private(i1 ,i2 ,i3 ,u1 ,u2 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n1 ,u ,i1 ,i2 ,i3 )
| 100
|
,i2 ,i3 ,u1 ,u2 )
for (i3 = 1; i3 < n3-1; i3++) {
for (i2 = 1; i2 < n2-1; i2++) {
<LOOP-START>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];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n1 ,u ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(j1 ,j2 ,j3 ,i1 ,i2 ,i3 ,x1 ,y1 ,x2 ,y2 )
| 100
|
{
d2 = 1;
}
if (m3k == 3) {
d3 = 2;
} else {
d3 = 1;
}
<LOOP-START>for (j3 = 1; j3 < m3j-1; j3++) {
i3 = 2*j3-d3;
/*C i3 = 2*j3-1*/
for (j2 = 1; j2 < m2j-1; j2++) {
i2 = 2*j2-d2;
/*C i2 = 2*j2-1*/
#pragma omp parallel for firstprivate(m1j ,d2 ,d3 ,i1 ,d1 ,i2 ,i3 ,r ,j1 ,j2 ,j3 )
for (j1 = 1; j1 < m1j; j1++) {
i1 = 2*j1-d1;
/*C i1 = 2*j1-1*/
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;
/*C i1 = 2*j1-1*/
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 private(j1 ,j2 ,j3 ,i1 ,i2 ,i3 ,x1 ,y1 ,x2 ,y2 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(m1j ,d2 ,d3 ,i1 ,d1 ,i2 ,i3 ,r ,j1 ,j2 ,j3 )
| 100
|
for (j2 = 1; j2 < m2j-1; j2++) {
i2 = 2*j2-d2;
/*C i2 = 2*j2-1*/
<LOOP-START>for (j1 = 1; j1 < m1j; j1++) {
i1 = 2*j1-d1;
/*C i1 = 2*j1-1*/
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];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(m1j ,d2 ,d3 ,i1 ,d1 ,i2 ,i3 ,r ,j1 ,j2 ,j3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 ,z1 ,z2 ,z3 )
| 100
|
parameter( m=535 )
*/
double z1[M], z2[M], z3[M];
if ( n1 != 3 && n2 != 3 && n3 != 3 ) {
<LOOP-START>for (i3 = 0; i3 < mm3-1; i3++) {
for (i2 = 0; i2 < mm2-1; i2++) {
#pragma omp parallel for firstprivate(mm1 ,z ,i1 ,i2 ,i3 )
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]);
}
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
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] );
}
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
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] );
}
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
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 private(i1 ,i2 ,i3 ,z1 ,z2 ,z3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(mm1 ,z ,i1 ,i2 ,i3 )
| 100
|
,i3 ,z1 ,z2 ,z3 )
for (i3 = 0; i3 < mm3-1; i3++) {
for (i2 = 0; i2 < mm2-1; i2++) {
<LOOP-START>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];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(mm1 ,z ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
| 100
|
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]);
}
<LOOP-START>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] );
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
| 100
|
[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] );
}
<LOOP-START>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] );
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(mm1 ,u ,i1 ,i2 ,i3 )
| 100
|
[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] );
}
<LOOP-START>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 firstprivate(mm1 ,u ,i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 )
| 100
|
d3 = 2;
t3 = 1;
} else {
d3 = 1;
t3 = 0;
}
{
<LOOP-START>for ( i3 = d3; i3 <= mm3-1; i3++) {
for ( i2 = d2; i2 <= mm2-1; i2++) {
for ( i1 = d1; i1 <= mm1-1; i1++) {
u[2*i3-d3-1][2*i2-d2-1][2*i1-d1-1] =
u[2*i3-d3-1][2*i2-d2-1][2*i1-d1-1]
+z[i3-1][i2-1][i1-1];
}
for ( i1 = 1; i1 <= mm1-1; i1++) {
u[2*i3-d3-1][2*i2-d2-1][2*i1-t1-1] =
u[2*i3-d3-1][2*i2-d2-1][2*i1-t1-1]
+0.5*(z[i3-1][i2-1][i1]+z[i3-1][i2-1][i1-1]);
}
}
for ( i2 = 1; i2 <= mm2-1; i2++) {
for ( i1 = d1; i1 <= mm1-1; i1++) {
u[2*i3-d3-1][2*i2-t2-1][2*i1-d1-1] =
u[2*i3-d3-1][2*i2-t2-1][2*i1-d1-1]
+0.5*(z[i3-1][i2][i1-1]+z[i3-1][i2-1][i1-1]);
}
for ( i1 = 1; i1 <= mm1-1; i1++) {
u[2*i3-d3-1][2*i2-t2-1][2*i1-t1-1] =
u[2*i3-d3-1][2*i2-t2-1][2*i1-t1-1]
+0.25*(z[i3-1][i2][i1]+z[i3-1][i2-1][i1]
+z[i3-1][i2][i1-1]+z[i3-1][i2-1][i1-1]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 )
| 100
|
z[i3-1][i2][i1]+z[i3-1][i2-1][i1]
+z[i3-1][i2][i1-1]+z[i3-1][i2-1][i1-1]);
}
}
}
<LOOP-START>for ( i3 = 1; i3 <= mm3-1; i3++) {
for ( i2 = d2; i2 <= mm2-1; i2++) {
for ( i1 = d1; i1 <= mm1-1; i1++) {
u[2*i3-t3-1][2*i2-d2-1][2*i1-d1-1] =
u[2*i3-t3-1][2*i2-d2-1][2*i1-d1-1]
+0.5*(z[i3][i2-1][i1-1]+z[i3-1][i2-1][i1-1]);
}
for ( i1 = 1; i1 <= mm1-1; i1++) {
u[2*i3-t3-1][2*i2-d2-1][2*i1-t1-1] =
u[2*i3-t3-1][2*i2-d2-1][2*i1-t1-1]
+0.25*(z[i3][i2-1][i1]+z[i3][i2-1][i1-1]
+z[i3-1][i2-1][i1]+z[i3-1][i2-1][i1-1]);
}
}
for ( i2 = 1; i2 <= mm2-1; i2++) {
for ( i1 = d1; i1 <= mm1-1; i1++) {
u[2*i3-t3-1][2*i2-t2-1][2*i1-d1-1] =
u[2*i3-t3-1][2*i2-t2-1][2*i1-d1-1]
+0.25*(z[i3][i2][i1-1]+z[i3][i2-1][i1-1]
+z[i3-1][i2][i1-1]+z[i3-1][i2-1][i1-1]);
}
for ( i1 = 1; i1 <= mm1-1; i1++) {
u[2*i3-t3-1][2*i2-t2-1][2*i1-t1-1] =
u[2*i3-t3-1][2*i2-t2-1][2*i1-t1-1]
+0.125*(z[i3][i2][i1]+z[i3][i2-1][i1]
+z[i3][i2][i1-1]+z[i3][i2-1][i1-1]
+z[i3-1][i2][i1]+z[i3-1][i2-1][i1]
+z[i3-1][i2][i1-1]+z[i3-1][i2-1][i1-1]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 ,a ) reduction(+:tmp) reduction(+:s)
| 100
|
double s = 0.0;
int i3, i2, i1, n;
double a = 0.0, tmp = 0.0;
n = nx*ny*nz;
<LOOP-START>for (i3 = 1; i3 < n3-1; i3++) {
#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
for (i2 = 1; i2 < n2-1; i2++) {
#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
for (i1 = 1; i1 < n1-1; i1++) {
s = s + r[i3][i2][i1] * r[i3][i2][i1];
a = fabs(r[i3][i2][i1]);
if (a > tmp) tmp = a;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ,a ) reduction(+:tmp) reduction(+:s) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
| 100
|
l for private(i1 ,i2 ,i3 ,a ) reduction(+:tmp) reduction(+:s)
for (i3 = 1; i3 < n3-1; i3++) {
<LOOP-START>for (i2 = 1; i2 < n2-1; i2++) {
#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
for (i1 = 1; i1 < n1-1; i1++) {
s = s + r[i3][i2][i1] * r[i3][i2][i1];
a = fabs(r[i3][i2][i1]);
if (a > tmp) tmp = a;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
| 100
|
,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
for (i2 = 1; i2 < n2-1; i2++) {
<LOOP-START>for (i1 = 1; i1 < n1-1; i1++) {
s = s + r[i3][i2][i1] * r[i3][i2][i1];
a = fabs(r[i3][i2][i1]);
if (a > tmp) tmp = a;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i2 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 )
| 100
|
--------------------------------------------------*/
int i1, i2, i3;
/* axis = 1 */
{
<LOOP-START>for ( i3 = 1; i3 < n3-1; i3++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,u ,n1 ,n2 ,i3 )
for ( i2 = 1; i2 < n2-1; i2++) {
u[i3][i2][n1-1] = u[i3][i2][1];
u[i3][i2][0] = u[i3][i2][n1-2];
}
// }<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,u ,n1 ,n2 ,i3 )
| 100
|
s = 1 */
{
#pragma omp parallel for private(i1 ,i2 ,i3 )
for ( i3 = 1; i3 < n3-1; i3++) {
<LOOP-START>for ( i2 = 1; i2 < n2-1; i2++) {
u[i3][i2][n1-1] = u[i3][i2][1];
u[i3][i2][0] = u[i3][i2][n1-2];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,u ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,u ,n1 ,n2 ,i3 )
| 100
|
i2][n1-2];
}
// }
/* axis = 2 */
//#pragma omp for
// for ( i3 = 1; i3 < n3-1; i3++) {
<LOOP-START>for ( i1 = 0; i1 < n1; i1++) {
u[i3][n2-1][i1] = u[i3][1][i1];
u[i3][0][i1] = u[i3][n2-2][i1];
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,u ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 )
| 100
|
i3][n2-1][i1] = u[i3][1][i1];
u[i3][0][i1] = u[i3][n2-2][i1];
}
}
/* axis = 3 */
<LOOP-START>for ( i2 = 0; i2 < n2; i2++) {
for ( i1 = 0; i1 < n1; i1++) {
u[n3-1][i2][i1] = u[1][i2][i1];
u[0][i2][i1] = u[n3-2][i2][i1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
ks for twenty candidates
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 0; i < MM; i++) {
ten[i][1] = 0.0;
j1[i][1] = 0;
j2[i][1] = 0;
j3[i][1] = 0;
ten[i][0] = 1.0;
j1[i][0] = 0;
j2[i][0] = 0;
j3[i][0] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i2 ,i1 )
| 100
|
n");
for (i = MM-1; i >= 0; i--) {
printf(" %4d", jg[0][i][1]);
}
printf("\n");*/
<LOOP-START>for (i3 = 0; i3 < n3; i3++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i2 ,i1 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
| 100
|
printf("\n");*/
#pragma omp parallel for private(i2 ,i1 )
for (i3 = 0; i3 < n3; i3++) {
<LOOP-START>for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
| 100
|
p parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i2 = 0; i2 < n2; i2++) {
<LOOP-START>for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i1 ,i2 ,i3 )
| 100
|
---
c-------------------------------------------------------------------*/
int i1, i2, i3;
<LOOP-START>for (i3 = 0;i3 < n3; i3++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1 ,i2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
| 100
|
nt i1, i2, i3;
#pragma omp parallel for private(i1 ,i2 ,i3 )
for (i3 = 0;i3 < n3; i3++) {
<LOOP-START>for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
| 100
|
p parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 )
for (i2 = 0; i2 < n2; i2++) {
<LOOP-START>for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(n3 ,i1 ,i2 ,z ,n1 ,n2 ,i3 ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/IS/is.c
|
#pragma omp parallel for firstprivate(i ) reduction(+:j)
| 100
|
2[i];
/* 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: %d\n",
j );
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) reduction(+:j) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/IS/is.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
est keys are, load into */
/* top of array bucket_size */
<LOOP-START>for( i=0; i<TEST_ARRAY_SIZE; i++ )
partial_verify_vals[i] = key_array[test_index_array[i]];
/* Clear the work array */
for( i=0; i<MAX_KEY; i++ )
key_buff1[i] = 0;
}
for (i=0; i<MAX_KEY; i++)
prv_buff1[i] = 0;
/* Copy keys into work array; keys in key_array will be reused each iter. */
#pragma omp for
for( i=0; i<NUM_KEYS; i++ ) {
key_buff2[i] = key_array[i];
/* 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 */
prv_buff1[key_buff2[i]]++; /* Now they have individual key */
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/IS/is.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
*/
for( i=0; i<MAX_KEY-1; i++ )
prv_buff1[i+1] += prv_buff1[i];
{
<LOOP-START>for( i=0; i<MAX_KEY; i++ )
key_buff1[i] += prv_buff1[i];
}
/* 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 */
{
/* 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 )
switch( CLASS )
{
case 'S':
if( i <= 2 )
{
if( key_buff1[k-1] != test_rank_array[i]+iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
else
{
if( key_buff1[k-1] != test_rank_array[i]-iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
break;
case 'W':
if( i < 2 )
{
if( key_buff1[k-1] !=
test_rank_array[i]+(iteration-2) )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
else
{
if( key_buff1[k-1] != test_rank_array[i]-iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
break;
case 'A':
if( i <= 2 )
{
if( key_buff1[k-1] !=
test_rank_array[i]+(iteration-1) )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
else
{
if( key_buff1[k-1] !=
test_rank_array[i]-(iteration-1) )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
break;
case 'B':
if( i == 1 || i == 2 || i == 4 )
{
if( key_buff1[k-1] != test_rank_array[i]+iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
else
{
if( key_buff1[k-1] != test_rank_array[i]-iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
break;
case 'C':
if( i <= 2 )
{
if( key_buff1[k-1] != test_rank_array[i]+iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
else
{
if( key_buff1[k-1] != test_rank_array[i]-iteration )
{
printf( "Failed partial verification: "
"iteration %d, test key %d\n",
iteration, i );
}
else
passed_verification++;
}
break;
}
}
/* 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_buff1;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/baseline/NPB3.0-omp-c/IS/is.c
|
#pragma omp parallel for firstprivate(i )
| 100
|
le timecounter, maxtime;
/* Initialize the verification arrays if a valid class */
<LOOP-START>for( i=0; i<TEST_ARRAY_SIZE; i++ )
switch( CLASS )
{
case 'S':
test_index_array[i] = S_test_index_array[i];
test_rank_array[i] = S_test_rank_array[i];
break;
case 'A':
test_index_array[i] = A_test_index_array[i];
test_rank_array[i] = A_test_rank_array[i];
break;
case 'W':
test_index_array[i] = W_test_index_array[i];
test_rank_array[i] = W_test_rank_array[i];
break;
case 'B':
test_index_array[i] = B_test_index_array[i];
test_rank_array[i] = B_test_rank_array[i];
break;
case 'C':
test_index_array[i] = C_test_index_array[i];
test_rank_array[i] = C_test_rank_array[i];
break;
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i ) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB021-reductionmissing-orig-yes.c
|
#pragma omp parallel for private (temp,i,j)
| 100
|
oat u[100][100];
for (i = 0; i < len; i++)
for (j = 0; j < len; j++)
u[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len; i++)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp,i,j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB019-plusplus-var-yes.c
|
#pragma omp parallel for
| 100
|
i(argv[1]);
int input[inLen];
int output[inLen];
for (i=0; i<inLen; ++i)
input[i]=i;
<LOOP-START>for (i=0; i<inLen; ++i) {
output[outLen++] = input[i] ;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB012-minusminus-var-yes.c
|
#pragma omp parallel for
| 100
|
x[len];
for (i=0; i< len; i++)
{
if (i%2==0)
x[i]=5;
else
x[i]= -5;
}
<LOOP-START>for (i=numNodes-1 ; i>-1 ; --i) {
if (x[i]<=0) {
numNodes2-- ;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB022-reductionmissing-var-yes.c
|
#pragma omp parallel for private (temp,i,j)
| 100
|
loat u[len][len];
for (i = 0; i < len; i++)
for (j = 0; j < len; j++)
u[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len; i++)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp,i,j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB016-outputdep-orig-yes.c
|
#pragma omp parallel for
| 100
|
. x@74:5 vs. x@74:5
*/
#include <stdio.h>
int a[100];
int main()
{
int len=100;
int i,x=10;
<LOOP-START>for (i=0;i<len;i++)
{
a[i] = x;
x=i;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB109-orderedmissing-orig-yes.c
|
#pragma omp parallel for ordered
| 100
|
* Missing the ordered clause
* Data race pair: x@56:5 vs. x@56:5
* */
int main()
{
int x =0;
<LOOP-START>for (int i = 0; i < 100; ++i) {
x++;
}<LOOP-END> <OMP-START>#pragma omp parallel for ordered<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB008-indirectaccess4-orig-yes.c
|
#pragma omp parallel for
| 100
|
/ initialize segments touched by indexSet
for (i =521; i<= 2025; ++i)
{
base[i]=0.5*i;
}
<LOOP-START>for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0;
xa2[idx]+= 3.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB017-outputdep-var-yes.c
|
#pragma omp parallel for
| 100
|
ar* argv[])
{
int len=100;
if (argc>1)
len = atoi(argv[1]);
int a[len];
int i,x=10;
<LOOP-START>for (i=0;i<len;i++)
{
a[i] = x;
x=i;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB018-plusplus-orig-yes.c
|
#pragma omp parallel for
| 100
|
)
{
int i ;
int inLen=1000 ;
int outLen = 0;
for (i=0; i<inLen; ++i)
input[i]= i;
<LOOP-START>for (i=0; i<inLen; ++i)
{
output[outLen++] = input[i] ;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB035-truedepscalar-orig-yes.c
|
#pragma omp parallel for
| 100
|
int main(int argc, char* argv[])
{
int i;
int tmp;
tmp = 10;
int len=100;
int a[100];
<LOOP-START>for (i=0;i<len;i++)
{
a[i] = tmp;
tmp =a[i]+i;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB036-truedepscalar-var-yes.c
|
#pragma omp parallel for
| 100
|
nt i;
int tmp;
tmp = 10;
int len=100;
if (argc>1)
len = atoi(argv[1]);
int a[len];
<LOOP-START>for (i=0;i<len;i++)
{
a[i] = tmp;
tmp =a[i]+i;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB065-pireduction-orig-no.c
|
#pragma omp parallel for reduction(+:pi) private(x)
| 100
|
uble pi = 0.0;
long int i;
double x, interval_width;
interval_width = 1.0/(double)num_steps;
<LOOP-START>for (i = 0; i < num_steps; i++) {
x = (i+ 0.5) * interval_width;
pi += 1.0 / (x*x + 1.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:pi) private(x)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB020-privatemissing-var-yes.c
|
#pragma omp parallel for
| 100
|
nt len=100;
if (argc>1)
len = atoi(argv[1]);
int a[len];
for (i=0;i<len;i++)
a[i]=i;
<LOOP-START>for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB006-indirectaccess2-orig-yes.c
|
#pragma omp parallel for
| 100
|
/ initialize segments touched by indexSet
for (i =521; i<= 2025; ++i)
{
base[i]=0.5*i;
}
<LOOP-START>for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0;
xa2[idx]+= 3.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB111-linearmissing-orig-yes.c
|
#pragma omp parallel for
| 100
|
<len;i++)
{
a[i]=((double)i)/2.0;
b[i]=((double)i)/3.0;
c[i]=((double)i)/7.0;
}
<LOOP-START>for (i=0;i<len;i++)
{
c[j]+=a[i]*b[i];
j++;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB028-privatemissing-orig-yes.c
|
#pragma omp parallel for
| 100
|
char* argv[])
{
int i;
int tmp;
int len=100;
int a[100];
for (i=0;i<len;i++)
a[i]=i;
<LOOP-START>for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB003-antidep2-orig-yes.c
|
#pragma omp parallel for private(j)
| 100
|
0;
double a[20][20];
for (i=0; i< len; i++)
for (j=0; j<len; j++)
a[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len - 1; i += 1) {
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB005-indirectaccess1-orig-yes.c
|
#pragma omp parallel for schedule(static,1)
| 100
|
[i]=0.5*i;
}
// default static even scheduling may not trigger data race, using static,1 instead.
<LOOP-START>for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0 + i;
xa2[idx]+= 3.0 + i;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static,1)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB007-indirectaccess3-orig-yes.c
|
#pragma omp parallel for
| 100
|
/ initialize segments touched by indexSet
for (i =521; i<= 2025; ++i)
{
base[i]=0.5*i;
}
<LOOP-START>for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0;
xa2[idx]+= 3.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB011-minusminus-orig-yes.c
|
#pragma omp parallel for
| 100
|
ialize x[]
for (i=0; i< len; i++)
{
if (i%2==0)
x[i]=5;
else
x[i]= -5;
}
<LOOP-START>for (i=numNodes-1 ; i>-1 ; --i) {
if (x[i]<=0) {
numNodes2-- ;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/dataracebench/DRB004-antidep2-var-yes.c
|
#pragma omp parallel for private(j)
| 100
|
;
double a[len][len];
for (i=0; i< len; i++)
for (j=0; j<len; j++)
a[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len - 1; i += 1) {
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/b+tree/kernel/kernel_cpu_2.c
|
#pragma omp parallel for private (i, thid)
| 100
|
==================150
// private thread IDs
int thid;
int bid;
// process number of querries
<LOOP-START>for(bid = 0; bid < count; bid++){
// process levels of the tree
for(i = 0; i < maxheight; i++){
// process all leaves at each level
for(thid = 0; thid < threadsPerBlock; thid++){
if((knodes[currKnode[bid]].keys[thid] <= start[bid]) && (knodes[currKnode[bid]].keys[thid+1] > start[bid])){
// this conditional statement is inserted to avoid crush due to but in original code
// "offset[bid]" calculated below that later addresses part of knodes goes outside of its bounds cause segmentation fault
// more specifically, values saved into knodes->indices in the main function are out of bounds of knodes that they address
if(knodes[currKnode[bid]].indices[thid] < knodes_elem){
offset[bid] = knodes[currKnode[bid]].indices[thid];
}
}
if((knodes[lastKnode[bid]].keys[thid] <= end[bid]) && (knodes[lastKnode[bid]].keys[thid+1] > end[bid])){
// this conditional statement is inserted to avoid crush due to but in original code
// "offset_2[bid]" calculated below that later addresses part of knodes goes outside of its bounds cause segmentation fault
// more specifically, values saved into knodes->indices in the main function are out of bounds of knodes that they address
if(knodes[lastKnode[bid]].indices[thid] < knodes_elem){
offset_2[bid] = knodes[lastKnode[bid]].indices[thid];
}
}
}
// set for next tree level
currKnode[bid] = offset[bid];
lastKnode[bid] = offset_2[bid];
}
// process leaves
for(thid = 0; thid < threadsPerBlock; thid++){
// Find the index of the starting record
if(knodes[currKnode[bid]].keys[thid] == start[bid]){
recstart[bid] = knodes[currKnode[bid]].indices[thid];
}
}
// process leaves
for(thid = 0; thid < threadsPerBlock; thid++){
// Find the index of the ending record
if(knodes[lastKnode[bid]].keys[thid] == end[bid]){
reclength[bid] = knodes[lastKnode[bid]].indices[thid] - recstart[bid]+1;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i, thid)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/b+tree/kernel/kernel_cpu.c
|
#pragma omp parallel for private (i, thid)
| 100
|
==========150
// private thread IDs
int thid;
int bid;
int i;
// process number of querries
<LOOP-START>for(bid = 0; bid < count; bid++){
// process levels of the tree
for(i = 0; i < maxheight; i++){
// process all leaves at each level
for(thid = 0; thid < threadsPerBlock; thid++){
// if value is between the two keys
if((knodes[currKnode[bid]].keys[thid]) <= keys[bid] && (knodes[currKnode[bid]].keys[thid+1] > keys[bid])){
// this conditional statement is inserted to avoid crush due to but in original code
// "offset[bid]" calculated below that addresses knodes[] in the next iteration goes outside of its bounds cause segmentation fault
// more specifically, values saved into knodes->indices in the main function are out of bounds of knodes that they address
if(knodes[offset[bid]].indices[thid] < knodes_elem){
offset[bid] = knodes[offset[bid]].indices[thid];
}
}
}
// set for next tree level
currKnode[bid] = offset[bid];
}
//At this point, we have a candidate leaf node which may contain
//the target record. Check each key to hopefully find the record
// process all leaves at each level
for(thid = 0; thid < threadsPerBlock; thid++){
if(knodes[currKnode[bid]].keys[thid] == keys[bid]){
ans[bid].value = records[knodes[currKnode[bid]].indices[thid]].value;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i, thid)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/bfs/bfs.cpp
|
#pragma omp parallel for
| 100
|
/omp_set_num_threads(num_omp_threads);
#ifdef OMP_OFFLOAD
#pragma omp target
#endif
<LOOP-START>for(int tid = 0; tid < no_of_nodes; tid++ )
{
if (h_graph_mask[tid] == true){
h_graph_mask[tid]=false;
for(int i=h_graph_nodes[tid].starting; i<(h_graph_nodes[tid].no_of_edges + h_graph_nodes[tid].starting); i++)
{
int id = h_graph_edges[i];
if(!h_graph_visited[id])
{
h_cost[id]=h_cost[tid]+1;
h_updating_graph_mask[id]=true;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/bfs/bfs.cpp
|
#pragma omp parallel for
| 100
|
}
}
#ifdef OPEN
#ifdef OMP_OFFLOAD
#pragma omp target map(stop)
#endif
<LOOP-START>for(int tid=0; tid< no_of_nodes ; tid++ )
{
if (h_updating_graph_mask[tid] == true){
h_graph_mask[tid]=true;
h_graph_visited[tid]=true;
stop=true;
h_updating_graph_mask[tid]=false;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
OFFLOAD
#pragma omp declare target
#endif
template <typename T>
void copy(T* dst, T* src, int N)
{
<LOOP-START>for(int i = 0; i < N; i++)
{
dst[i] = src[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
] << std::endl;
}
}
void initialize_variables(int nelr, float* variables, float* ff_variable)
{
<LOOP-START>for(int i = 0; i < nelr; i++)
{
for(int j = 0; j < NVAR; j++) variables[i + j*nelr] = ff_variable[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu.cpp
|
#pragma omp parallel for default(shared) schedule(auto)
| 100
|
step_factor(int nelr, float* __restrict variables, float* areas, float* __restrict step_factors)
{
<LOOP-START>for(int blk = 0; blk < nelr/block_length; ++blk)
{
int b_start = blk*block_length;
int b_end = (blk+1)*block_length > nelr ? nelr : (blk+1)*block_length;
#pragma omp simd
for(int i = b_start; i < b_end; i++)
{
float density = variables[i + VAR_DENSITY*nelr];
float3 momentum;
momentum.x = variables[i + (VAR_MOMENTUM+0)*nelr];
momentum.y = variables[i + (VAR_MOMENTUM+1)*nelr];
momentum.z = variables[i + (VAR_MOMENTUM+2)*nelr];
float density_energy = variables[i + VAR_DENSITY_ENERGY*nelr];
float3 velocity; compute_velocity(density, momentum, velocity);
float speed_sqd = compute_speed_sqd(velocity);
float pressure = compute_pressure(density, density_energy, speed_sqd);
float speed_of_sound = compute_speed_of_sound(density, pressure);
// dt = float(0.5f) * std::sqrt(areas[i]) / (||v|| + c).... but when we do time stepping, this later would need to be divided by the area, so we just do it all at once
step_factors[i] = float(0.5f) / (std::sqrt(areas[i]) * (std::sqrt(speed_sqd) + speed_of_sound));
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(auto)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu.cpp
|
#pragma omp parallel for default(shared) schedule(auto)
| 100
|
, float3 ff_flux_contribution_density_energy)
{
const float smoothing_coefficient = float(0.2f);
<LOOP-START>for(int blk = 0; blk < nelr/block_length; ++blk)
{
int b_start = blk*block_length;
int b_end = (blk+1)*block_length > nelr ? nelr : (blk+1)*block_length;
#pragma omp simd
for(int i = b_start; i < b_end; ++i)
{
float density_i = variables[i + VAR_DENSITY*nelr];
float3 momentum_i;
momentum_i.x = variables[i + (VAR_MOMENTUM+0)*nelr];
momentum_i.y = variables[i + (VAR_MOMENTUM+1)*nelr];
momentum_i.z = variables[i + (VAR_MOMENTUM+2)*nelr];
float density_energy_i = variables[i + VAR_DENSITY_ENERGY*nelr];
float3 velocity_i; compute_velocity(density_i, momentum_i, velocity_i);
float speed_sqd_i = compute_speed_sqd(velocity_i);
float speed_i = std::sqrt(speed_sqd_i);
float pressure_i = compute_pressure(density_i, density_energy_i, speed_sqd_i);
float speed_of_sound_i = compute_speed_of_sound(density_i, pressure_i);
float3 flux_contribution_i_momentum_x, flux_contribution_i_momentum_y, flux_contribution_i_momentum_z;
float3 flux_contribution_i_density_energy;
compute_flux_contribution(density_i, momentum_i, density_energy_i, pressure_i, velocity_i, flux_contribution_i_momentum_x, flux_contribution_i_momentum_y, flux_contribution_i_momentum_z, flux_contribution_i_density_energy);
float flux_i_density = float(0.0f);
float3 flux_i_momentum;
flux_i_momentum.x = float(0.0f);
flux_i_momentum.y = float(0.0f);
flux_i_momentum.z = float(0.0f);
float flux_i_density_energy = float(0.0f);
float3 velocity_nb;
float density_nb, density_energy_nb;
float3 momentum_nb;
float3 flux_contribution_nb_momentum_x, flux_contribution_nb_momentum_y, flux_contribution_nb_momentum_z;
float3 flux_contribution_nb_density_energy;
float speed_sqd_nb, speed_of_sound_nb, pressure_nb;
#pragma unroll
for(int j = 0; j < NNB; j++)
{
float3 normal; float normal_len;
float factor;
int nb = elements_surrounding_elements[i + j*nelr];
normal.x = normals[i + (j + 0*NNB)*nelr];
normal.y = normals[i + (j + 1*NNB)*nelr];
normal.z = normals[i + (j + 2*NNB)*nelr];
normal_len = std::sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z);
if(nb >= 0) // a legitimate neighbor
{
density_nb = variables[nb + VAR_DENSITY*nelr];
momentum_nb.x = variables[nb + (VAR_MOMENTUM+0)*nelr];
momentum_nb.y = variables[nb + (VAR_MOMENTUM+1)*nelr];
momentum_nb.z = variables[nb + (VAR_MOMENTUM+2)*nelr];
density_energy_nb = variables[nb + VAR_DENSITY_ENERGY*nelr];
compute_velocity(density_nb, momentum_nb, velocity_nb);
speed_sqd_nb = compute_speed_sqd(velocity_nb);
pressure_nb = compute_pressure(density_nb, density_energy_nb, speed_sqd_nb);
speed_of_sound_nb = compute_speed_of_sound(density_nb, pressure_nb);
compute_flux_contribution(density_nb, momentum_nb, density_energy_nb, pressure_nb, velocity_nb, flux_contribution_nb_momentum_x, flux_contribution_nb_momentum_y, flux_contribution_nb_momentum_z, flux_contribution_nb_density_energy);
// artificial viscosity
factor = -normal_len*smoothing_coefficient*float(0.5f)*(speed_i + std::sqrt(speed_sqd_nb) + speed_of_sound_i + speed_of_sound_nb);
flux_i_density += factor*(density_i-density_nb);
flux_i_density_energy += factor*(density_energy_i-density_energy_nb);
flux_i_momentum.x += factor*(momentum_i.x-momentum_nb.x);
flux_i_momentum.y += factor*(momentum_i.y-momentum_nb.y);
flux_i_momentum.z += factor*(momentum_i.z-momentum_nb.z);
// accumulate cell-centered fluxes
factor = float(0.5f)*normal.x;
flux_i_density += factor*(momentum_nb.x+momentum_i.x);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.x+flux_contribution_i_density_energy.x);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.x+flux_contribution_i_momentum_x.x);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.x+flux_contribution_i_momentum_y.x);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.x+flux_contribution_i_momentum_z.x);
factor = float(0.5f)*normal.y;
flux_i_density += factor*(momentum_nb.y+momentum_i.y);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.y+flux_contribution_i_density_energy.y);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.y+flux_contribution_i_momentum_x.y);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.y+flux_contribution_i_momentum_y.y);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.y+flux_contribution_i_momentum_z.y);
factor = float(0.5f)*normal.z;
flux_i_density += factor*(momentum_nb.z+momentum_i.z);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.z+flux_contribution_i_density_energy.z);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.z+flux_contribution_i_momentum_x.z);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.z+flux_contribution_i_momentum_y.z);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.z+flux_contribution_i_momentum_z.z);
}
else if(nb == -1) // a wing boundary
{
flux_i_momentum.x += normal.x*pressure_i;
flux_i_momentum.y += normal.y*pressure_i;
flux_i_momentum.z += normal.z*pressure_i;
}
else if(nb == -2) // a far field boundary
{
factor = float(0.5f)*normal.x;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+0]+momentum_i.x);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.x+flux_contribution_i_density_energy.x);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.x + flux_contribution_i_momentum_x.x);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.x + flux_contribution_i_momentum_y.x);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.x + flux_contribution_i_momentum_z.x);
factor = float(0.5f)*normal.y;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+1]+momentum_i.y);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.y+flux_contribution_i_density_energy.y);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.y + flux_contribution_i_momentum_x.y);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.y + flux_contribution_i_momentum_y.y);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.y + flux_contribution_i_momentum_z.y);
factor = float(0.5f)*normal.z;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+2]+momentum_i.z);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.z+flux_contribution_i_density_energy.z);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.z + flux_contribution_i_momentum_x.z);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.z + flux_contribution_i_momentum_y.z);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.z + flux_contribution_i_momentum_z.z);
}
}
fluxes[i + VAR_DENSITY*nelr] = flux_i_density;
fluxes[i + (VAR_MOMENTUM+0)*nelr] = flux_i_momentum.x;
fluxes[i + (VAR_MOMENTUM+1)*nelr] = flux_i_momentum.y;
fluxes[i + (VAR_MOMENTUM+2)*nelr] = flux_i_momentum.z;
fluxes[i + VAR_DENSITY_ENERGY*nelr] = flux_i_density_energy;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(auto)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu.cpp
|
#pragma omp parallel for default(shared) schedule(auto)
| 100
|
(int j, int nelr, float* old_variables, float* variables, float* step_factors, float* fluxes)
{
<LOOP-START>for(int blk = 0; blk < nelr/block_length; ++blk)
{
int b_start = blk*block_length;
int b_end = (blk+1)*block_length > nelr ? nelr : (blk+1)*block_length;
#pragma omp simd
for(int i = b_start; i < b_end; ++i)
{
float factor = step_factors[i]/float(RK+1-j);
variables[i + VAR_DENSITY*nelr] = old_variables[i + VAR_DENSITY*nelr] + factor*fluxes[i + VAR_DENSITY*nelr];
variables[i + (VAR_MOMENTUM+0)*nelr] = old_variables[i + (VAR_MOMENTUM+0)*nelr] + factor*fluxes[i + (VAR_MOMENTUM+0)*nelr];
variables[i + (VAR_MOMENTUM+1)*nelr] = old_variables[i + (VAR_MOMENTUM+1)*nelr] + factor*fluxes[i + (VAR_MOMENTUM+1)*nelr];
variables[i + (VAR_MOMENTUM+2)*nelr] = old_variables[i + (VAR_MOMENTUM+2)*nelr] + factor*fluxes[i + (VAR_MOMENTUM+2)*nelr];
variables[i + VAR_DENSITY_ENERGY*nelr] = old_variables[i + VAR_DENSITY_ENERGY*nelr] + factor*fluxes[i + VAR_DENSITY_ENERGY*nelr];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(auto)<OMP-END>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.