filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 100 | {
rhs[m][i][j][k] = rhs[m][i][j][k] -
lhs[n+3][i][j][k]*rhs[m][i1][j][k];
}
}
}
<LOOP-START>for (m = 3; m < 5; m++) {
#pragma omp parallel for private(n)
for (j = 1; j <= grid_points[1]-2; j++) {
#pragma omp parallel for private(n)
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][i1][j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 100 | 1][j][k];
}
}
}
#pragma omp parallel for private(n)
for (m = 3; m < 5; m++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
#pragma omp parallel for private(n)
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][i1][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 100 | m++) {
#pragma omp parallel for private(n)
for (j = 1; j <= grid_points[1]-2; j++) {
<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][i1][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | ------*/
n = 0;
for (i = grid_points[0]-3; i >= 0; i--) {
i1 = i + 1;
i2 = i + 2;
<LOOP-START>for (m = 0; m < 3; m++) {
#pragma omp parallel for
for (j = 1; j <= grid_points[1]-2; j++) {
#pragma omp parallel for
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][i1][j][k] -
lhs[n+4][i][j][k]*rhs[m][i2][j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | i1 = i + 1;
i2 = i + 2;
#pragma omp parallel for
for (m = 0; m < 3; m++) {
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
#pragma omp parallel for
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][i1][j][k] -
lhs[n+4][i][j][k]*rhs[m][i2][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | 0; m < 3; m++) {
#pragma omp parallel for
for (j = 1; j <= grid_points[1]-2; j++) {
<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][i1][j][k] -
lhs[n+4][i][j][k]*rhs[m][i2][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, i1, i2) | 100 | And the remaining two
--------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
for (i = grid_points[0]-3; i >= 0; i--) {
i1 = i + 1;
i2 = i + 2;
#pragma omp parallel for
for (j = 1; j <= grid_points[1]-2; j++) {
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][i1][j][k] -
lhs[n+4][i][j][k]*rhs[m][i2][j][k];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n, i1, i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | m-3+1)*5;
for (i = grid_points[0]-3; i >= 0; i--) {
i1 = i + 1;
i2 = i + 2;
<LOOP-START>for (j = 1; j <= grid_points[1]-2; j++) {
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][i1][j][k] -
lhs[n+4][i][j][k]*rhs[m][i2][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1) | 100 | hsy();
n = 0;
for (j = 0; j <= grid_points[1]-3; j++) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(fac1)
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
}
lhs[n+1][i][j2][k] = lhs[n+1][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+3][i][j][k];
lhs[n+2][i][j2][k] = lhs[n+2][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j2][k] = rhs[m][i][j2][k] -
lhs[n+0][i][j2][k]*rhs[m][i][j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1) | 100 | + 2;
#pragma omp parallel for private(fac1)
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
}
lhs[n+1][i][j2][k] = lhs[n+1][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+3][i][j][k];
lhs[n+2][i][j2][k] = lhs[n+2][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j2][k] = rhs[m][i][j2][k] -
lhs[n+0][i][j2][k]*rhs[m][i][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1, fac2) | 100 | --------------------------------------------*/
j = grid_points[1]-2;
j1 = grid_points[1]-1;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(fac1, fac2)
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
}
/*--------------------------------------------------------------------
c scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j1][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = fac2*rhs[m][i][j1][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(fac1, fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1, fac2) | 100 | ]-1;
#pragma omp parallel for private(fac1, fac2)
for (i = 1; i <= grid_points[0]-2; i++) {
<LOOP-START>for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
}
/*--------------------------------------------------------------------
c scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j1][k];
for (m = 0; m < 3; m++) {
rhs[m][i][j1][k] = fac2*rhs[m][i][j1][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(fac1, fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, j1, j2, fac1) | 100 | c factors
--------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
for (j = 0; j <= grid_points[1]-3; j++) {
j1 = j + 1;
j2 = j + 2;
#pragma omp parallel for private(n, j1, j2, fac1)
for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
lhs[n+1][i][j2][k] = lhs[n+1][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+3][i][j][k];
lhs[n+2][i][j2][k] = lhs[n+2][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+4][i][j][k];
rhs[m][i][j2][k] = rhs[m][i][j2][k] -
lhs[n+0][i][j2][k]*rhs[m][i][j][k];
}
}
}
/*--------------------------------------------------------------------
c And again the last two rows separately
--------------------------------------------------------------------*/
j = grid_points[1]-2;
j1 = grid_points[1]-1;
#pragma omp parallel for private(fac1, fac2)
for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j1][k];
rhs[m][i][j1][k] = fac2*rhs[m][i][j1][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n, j1, j2, fac1) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, j1, j2, fac1) | 100 | m-3+1)*5;
for (j = 0; j <= grid_points[1]-3; j++) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
lhs[n+1][i][j2][k] = lhs[n+1][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+3][i][j][k];
lhs[n+2][i][j2][k] = lhs[n+2][i][j2][k] -
lhs[n+0][i][j2][k]*lhs[n+4][i][j][k];
rhs[m][i][j2][k] = rhs[m][i][j2][k] -
lhs[n+0][i][j2][k]*rhs[m][i][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(n, j1, j2, fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1, fac2) | 100 | ---------------------------------------*/
j = grid_points[1]-2;
j1 = grid_points[1]-1;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (k = 1; k <= grid_points[2]-2; k++) {
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][j1][k] = lhs[n+2][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+3][i][j][k];
lhs[n+3][i][j1][k] = lhs[n+3][i][j1][k] -
lhs[n+1][i][j1][k]*lhs[n+4][i][j][k];
rhs[m][i][j1][k] = rhs[m][i][j1][k] -
lhs[n+1][i][j1][k]*rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1./lhs[n+2][i][j1][k];
rhs[m][i][j1][k] = fac2*rhs[m][i][j1][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(fac1, fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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
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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 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 private(n)
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(n)
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 private(n) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 100 | ][j1][k];
}
}
}
#pragma omp parallel for private(n)
for (m = 3; m < 5; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(n)
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 private(n)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n) | 100 | m++) {
#pragma omp parallel for private(n)
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 private(n) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(j1, j2) | 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 private(j1, j2)
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(j1, j2)
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 private(j1, j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(j1, j2) | 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 private(j1, j2)
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 private(j1, j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(j1, j2) | 100 | 2;
#pragma omp parallel for private(j1, j2)
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 private(j1, j2) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, j1, j2) | 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 private(n, j1, j2) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2, fac1) | 100 | ON
c-------------------------------------------------------------------*/
lhsz();
n = 0;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(k1, k2, fac1)
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 private(k1, k2, fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2, fac1) | 100 | ;
#pragma omp parallel for private(k1, k2, fac1)
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 private(k1, k2, fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1) | 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 private(fac1)
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 private(fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1) | 100 | ints[2]-1;
#pragma omp parallel for private(fac1)
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 private(fac1) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, k1, k2, fac1) | 100 | u-c factors
c-------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
#pragma omp parallel for private(k1, k2, fac1)
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(k1, k2, fac1)
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 private(fac1, fac2)
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 private(n, k1, k2, fac1) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2, fac1) | 100 | ragma omp parallel for private(n, k1, k2, fac1)
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 private(k1, k2, fac1)
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 private(k1, k2, fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2, fac1) | 100 | #pragma omp parallel for private(k1, k2, fac1)
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 private(k1, k2, fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(fac1, fac2) | 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 private(fac1, fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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
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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(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
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 private(n) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | }
}
#pragma omp parallel for private(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
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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2) | 100 | rst three factors
c-------------------------------------------------------------------*/
n = 0;
<LOOP-START>for (m = 0; m < 3; m++) {
#pragma omp parallel for private(k1, k2)
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(k1, k2)
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 private(k1, k2) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2) | 100 | ------------*/
n = 0;
#pragma omp parallel for private(k1, k2)
for (m = 0; m < 3; m++) {
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(k1, k2)
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 private(k1, k2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2) | 100 | {
#pragma omp parallel for private(k1, k2)
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 private(k1, k2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(n, k1, k2) | 100 | And the remaining two
c-------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m < 5; m++) {
n = (m-3+1)*5;
#pragma omp parallel for private(k1, k2)
for (i = 1; i <= grid_points[0]-2; i++) {
#pragma omp parallel for private(k1, k2)
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 private(n, k1, k2) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2) | 100 | /
#pragma omp parallel for private(n, k1, k2)
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 private(k1, k2)
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 private(k1, k2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private(k1, k2) | 100 | 5;
#pragma omp parallel for private(k1, k2)
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 private(k1, k2) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for | 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 copyin(x, qq) private(x1, x2, t1, t2, t3, t4, ik, kk, i, l) 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for copyin(x, qq) private(x1, x2, t1, t2, t3, t4, ik, kk, i, l) reduction(+:sx) reduction(+:sy) | 100 | opy of q[0:NQ-1] */
#pragma omp parallel for
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 copyin(x, qq) private(x1, x2, t1, t2, t3, t4, ik, kk, i, l) reduction(+:sx) reduction(+:sy) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for | 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 private(i ) reduction(+:gc)
for (i = 0; i <= NQ-1; i++) {
gc = gc + q[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private(i ) reduction(+:gc) | 100 | threads = 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 private(i ) reduction(+:gc) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(lt ) | 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 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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 ,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 ,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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n1 ,r ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n1 ,c ,r ,u ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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 ,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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n1 ,u ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(j1 ,j2 ,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 ,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 ,i1 ,i2 ,i3 ,x1 ,y1 ,x2 ,y2 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(m1j ,d2 ,d3 ,i1 ,d1 ,i2 ,i3 ,r ,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 ,j2 ,j3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(i1 ,i2 ,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 ,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 ,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 ,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 ,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 ,z1 ,z2 ,z3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(mm1 ,z ,i2 ,i3 ) | 100 | ,i2 ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(mm1 ,u ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(mm1 ,u ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(mm1 ,u ,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 ,i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(i1 ,i2) | 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) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(i1 ,i2) | 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) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(i1 ,i2 ,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 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s)
for (i2 = 1; i2 < n2-1; i2++) {
#pragma omp parallel for firstprivate(n3 ,i2 ,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 ,a ) reduction(+:tmp) reduction(+:s) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s) | 100 | allel for private(i1 ,i2 ,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 ,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 ,i1 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,i2 ,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 ,r ,n1 ,n2 ,i3 ) reduction(+:tmp) reduction(+:s) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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 ,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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,i1 ,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 ,u ,n1 ,n2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,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 ,i2 ,u ,n1 ,n2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private(i1 ,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 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for | 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 <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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 ,z ,n1 ,n2 ,i3 )
for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(n3 ,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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,i1 ,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 ,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 ,z ,n1 ,n2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(n3 ,i2 ,z ,n1 ,n2 ,i3 ) | 100 | a omp parallel for firstprivate(n3 ,i1 ,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 ,i2 ,z ,n1 ,n2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/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(i3 )
for (i2 = 0; i2 < n2; i2++) {
#pragma omp parallel for firstprivate(i2 ,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> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(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(i2 ,i3 )
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for firstprivate(i2 ,i3 ) | 100 | n3; i3++) {
#pragma omp parallel for firstprivate(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(i2 ,i3 ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private(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 private(i ) reduction(+:j) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private(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. */
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 private(i ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private(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 private(i ) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private(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 private(i ) <OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c1,c2) firstprivate (n) | 100 | 00][500],double B[500][500])
{
//int i;
//int j;
{
int c1;
int c2;
if (n >= 1) {
<LOOP-START>for (c1 = 0; c1 <= n + -1; c1 += 1) {
#pragma omp parallel for private (c2)
for (c2 = 0; c2 <= n + -1; c2 += 1) {
X[c1][c2] = (((double )c1) * (c2 + 1) + 1) / n;
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c1,c2) firstprivate (n)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c2) | 100 | parallel for private (c1,c2) firstprivate (n)
for (c1 = 0; c1 <= n + -1; c1 += 1) {
<LOOP-START>for (c2 = 0; c2 <= n + -1; c2 += 1) {
X[c1][c2] = (((double )c1) * (c2 + 1) + 1) / n;
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c2,c8) | 100 | 2;
//#pragma scop
{
int c0;
int c2;
int c8;
for (c0 = 0; c0 <= 9; c0 += 1) {
<LOOP-START>for (c2 = 0; c2 <= 499; c2 += 1) {
for (c8 = 1; c8 <= 499; c8 += 1) {
B[c2][c8] = B[c2][c8] - A[c2][c8] * A[c2][c8] / B[c2][c8 - 1];
}
for (c8 = 1; c8 <= 499; c8 += 1) {
X[c2][c8] = X[c2][c8] - X[c2][c8 - 1] * A[c2][c8] / B[c2][c8 - 1];
}
for (c8 = 0; c8 <= 497; c8 += 1) {
X[c2][500 - c8 - 2] = (X[c2][500 - 2 - c8] - X[c2][500 - 2 - c8 - 1] * A[c2][500 - c8 - 3]) / B[c2][500 - 3 - c8];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c2,c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c2) | 100 | 8] - X[c2][500 - 2 - c8 - 1] * A[c2][500 - c8 - 3]) / B[c2][500 - 3 - c8];
}
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2 += 1) {
X[c2][500 - 1] = X[c2][500 - 1] / B[c2][500 - 1];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c2,c8) | 100 | = 0; c2 <= 499; c2 += 1) {
X[c2][500 - 1] = X[c2][500 - 1] / B[c2][500 - 1];
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2 += 1) {
for (c8 = 1; c8 <= 499; c8 += 1) {
B[c8][c2] = B[c8][c2] - A[c8][c2] * A[c8][c2] / B[c8 - 1][c2];
}
for (c8 = 1; c8 <= 499; c8 += 1) {
X[c8][c2] = X[c8][c2] - X[c8 - 1][c2] * A[c8][c2] / B[c8 - 1][c2];
}
for (c8 = 0; c8 <= 497; c8 += 1) {
X[500 - 2 - c8][c2] = (X[500 - 2 - c8][c2] - X[500 - c8 - 3][c2] * A[500 - 3 - c8][c2]) / B[500 - 2 - c8][c2];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c2,c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private (c2) | 100 | 8][c2] - X[500 - c8 - 3][c2] * A[500 - 3 - c8][c2]) / B[500 - 2 - c8][c2];
}
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2 += 1) {
X[500 - 1][c2] = X[500 - 1][c2] / B[500 - 1][c2];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB009-lastprivatemissing-orig-yes.c | #pragma omp parallel for private (i) lastprivate (x) firstprivate (len) | 100 | dio.h>
#include <omp.h>
int main(int argc,char *argv[])
{
int i;
int x;
int len = 10000;
<LOOP-START>for (i = 0; i <= len - 1; i += 1) {
x = i;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) lastprivate (x) firstprivate (len)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private (i,j) | 100 | gv[])
{
int i;
int j;
float temp;
float sum = 0.0;
int len = 100;
float u[100][100];
<LOOP-START>for (i = 0; i <= len - 1; i += 1) {
#pragma omp parallel for private (j)
for (j = 0; j <= len - 1; j += 1) {
u[i][j] = 0.5;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i,j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private (j) | 100 | t u[100][100];
#pragma omp parallel for private (i,j)
for (i = 0; i <= len - 1; i += 1) {
<LOOP-START>for (j = 0; j <= len - 1; j += 1) {
u[i][j] = 0.5;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private (temp,i,j) reduction (+:sum) firstprivate (len) | 100 | parallel for private (j)
for (j = 0; j <= len - 1; j += 1) {
u[i][j] = 0.5;
}
}
<LOOP-START>for (i = 0; i <= len - 1; i += 1) {
#pragma omp parallel for private (temp,j) reduction (+:sum)
for (j = 0; j <= len - 1; j += 1) {
temp = u[i][j];
sum = sum + temp * temp;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp,i,j) reduction (+:sum) firstprivate (len)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private (temp,j) reduction (+:sum) | 100 | private (temp,i,j) reduction (+:sum) firstprivate (len)
for (i = 0; i <= len - 1; i += 1) {
<LOOP-START>for (j = 0; j <= len - 1; j += 1) {
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp,j) reduction (+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB019-plusplus-var-yes.c | #pragma omp parallel for private (i) | 100 | outLen = 0;
if (argc > 1)
inLen = atoi(argv[1]);
int input[inLen];
int output[inLen];
<LOOP-START>for (i = 0; i <= inLen - 1; i += 1) {
input[i] = i;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB012-minusminus-var-yes.c | #pragma omp parallel for private (i) firstprivate (len) | 100 | if (argc > 1)
len = atoi(argv[1]);
int numNodes = len;
int numNodes2 = 0;
int x[len];
<LOOP-START>for (i = 0; i <= len - 1; i += 1) {
if (i % 2 == 0)
x[i] = 5;
else
x[i] = - 5;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) firstprivate (len)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB012-minusminus-var-yes.c | #pragma omp parallel for private (i) reduction (-:numNodes2) | 100 | 0; i <= len - 1; i += 1) {
if (i % 2 == 0)
x[i] = 5;
else
x[i] = - 5;
}
<LOOP-START>for (i = numNodes - 1; i >= 0; i += -1) {
if (x[i] <= 0) {
numNodes2--;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) reduction (-:numNodes2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/dataracebench/DRB022-reductionmissing-var-yes.c | #pragma omp parallel for private (i,j) | 100 | float sum = 0.0;
int len = 100;
if (argc > 1)
len = atoi(argv[1]);
float u[len][len];
<LOOP-START>for (i = 0; i <= len - 1; i += 1) {
#pragma omp parallel for private (j)
for (j = 0; j <= len - 1; j += 1) {
u[i][j] = 0.5;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i,j)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.