filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac2) | 100 | ----------------------------------------------*/
fac2 = 1. / lhs[n + 2][i1][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i1][j][k] = fac2 * rhs[m][i1][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,j,k) | 100 | for (i = 0; i <= grid_points[0] - 3; i += 1) {
i1 = i + 1;
i2 = i + 2;
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (fac1,k) firstprivate (n,i1,i2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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][i1][j][k] = lhs[n + 2][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 3][i][j][k];
lhs[n + 3][i1][j][k] = lhs[n + 3][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 4][i][j][k];
rhs[m][i1][j][k] = rhs[m][i1][j][k] - lhs[n + 1][i1][j][k] * rhs[m][i][j][k];
lhs[n + 1][i2][j][k] = lhs[n + 1][i2][j][k] - lhs[n + 0][i2][j][k] * lhs[n + 3][i][j][k];
lhs[n + 2][i2][j][k] = lhs[n + 2][i2][j][k] - lhs[n + 0][i2][j][k] * lhs[n + 4][i][j][k];
rhs[m][i2][j][k] = rhs[m][i2][j][k] - lhs[n + 0][i2][j][k] * rhs[m][i][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,k) firstprivate (n,i1,i2) | 100 | p parallel for private (fac1,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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][i1][j][k] = lhs[n + 2][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 3][i][j][k];
lhs[n + 3][i1][j][k] = lhs[n + 3][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 4][i][j][k];
rhs[m][i1][j][k] = rhs[m][i1][j][k] - lhs[n + 1][i1][j][k] * rhs[m][i][j][k];
lhs[n + 1][i2][j][k] = lhs[n + 1][i2][j][k] - lhs[n + 0][i2][j][k] * lhs[n + 3][i][j][k];
lhs[n + 2][i2][j][k] = lhs[n + 2][i2][j][k] - lhs[n + 0][i2][j][k] * lhs[n + 4][i][j][k];
rhs[m][i2][j][k] = rhs[m][i2][j][k] - lhs[n + 0][i2][j][k] * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,k) firstprivate (n,i1,i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,j,k) | 100 | -----------------------------*/
i = grid_points[0] - 2;
i1 = grid_points[0] - 1;
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (fac1,fac2,k) firstprivate (i,n,i1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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][i1][j][k] = lhs[n + 2][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 3][i][j][k];
lhs[n + 3][i1][j][k] = lhs[n + 3][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 4][i][j][k];
rhs[m][i1][j][k] = rhs[m][i1][j][k] - lhs[n + 1][i1][j][k] * rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1. / lhs[n + 2][i1][j][k];
rhs[m][i1][j][k] = fac2 * rhs[m][i1][j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,k) firstprivate (i,n,i1) | 100 | parallel for private (fac1,fac2,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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][i1][j][k] = lhs[n + 2][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 3][i][j][k];
lhs[n + 3][i1][j][k] = lhs[n + 3][i1][j][k] - lhs[n + 1][i1][j][k] * lhs[n + 4][i][j][k];
rhs[m][i1][j][k] = rhs[m][i1][j][k] - lhs[n + 1][i1][j][k] * rhs[m][i][j][k];
/*--------------------------------------------------------------------
c Scale the last row immediately
--------------------------------------------------------------------*/
fac2 = 1. / lhs[n + 2][i1][j][k];
rhs[m][i1][j][k] = fac2 * rhs[m][i1][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,k) firstprivate (i,n,i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j,k,m) | 100 | ------------------------*/
i = grid_points[0] - 2;
i1 = grid_points[0] - 1;
n = 0;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
#pragma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (i,n,i1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j,k) | 100 | ;
n = 0;
#pragma omp parallel for private (j,k,m)
for (m = 0; m <= 2; m += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (i,n,i1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (i,n,i1) | 100 | pragma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (i,n,i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,j,k,m) | 100 | ][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 <= 4; m += 1) {
#pragma omp parallel for private (n,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (n,k) firstprivate (i,i1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,j,k) | 100 | }
}
#pragma omp parallel for private (n,j,k,m)
for (m = 3; m <= 4; m += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (n,k) firstprivate (i,i1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,k) firstprivate (i,i1) | 100 | agma omp parallel for private (n,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,k) firstprivate (i,i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j,k,m) | 100 | = 0;
for (i = grid_points[0] - 3; i >= 0; i += -1) {
i1 = i + 1;
i2 = i + 2;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
#pragma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (n,i1,i2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j,k) | 100 | i + 2;
#pragma omp parallel for private (j,k,m)
for (m = 0; m <= 2; m += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (n,i1,i2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (n,i1,i2) | 100 | ma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (n,i1,i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,i1,i2,i,j,k,m) | 100 | And the remaining two
--------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
for (i = grid_points[0] - 3; i >= 0; i += -1) {
i1 = i + 1;
i2 = i + 2;
#pragma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (n,i1,i2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j,k) | 100 | for (i = grid_points[0] - 3; i >= 0; i += -1) {
i1 = i + 1;
i2 = i + 2;
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
#pragma omp parallel for private (k) firstprivate (n,i1,i2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (n,i1,i2) | 100 | ma omp parallel for private (j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (n,i1,i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,i,k,m) | 100 | = 0;
for (j = 0; j <= grid_points[1] - 3; j += 1) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,k,m) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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,i,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,k,m) firstprivate (n,j1,j2) | 100 | omp parallel for private (fac1,i,k,m)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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,k,m) firstprivate (n,j1,j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac1) | 100 | fac1 * lhs[n + 3][i][j][k];
lhs[n + 4][i][j][k] = fac1 * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k] = fac1 * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) | 100 | hs[n + 3][i][j1][k] = lhs[n + 3][i][j1][k] - lhs[n + 1][i][j1][k] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] - lhs[n + 1][i][j1][k] * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) | 100 | hs[n + 2][i][j2][k] = lhs[n + 2][i][j2][k] - lhs[n + 0][i][j2][k] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
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 (m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,i,k,m) | 100 | -----------------------------------*/
j = grid_points[1] - 2;
j1 = grid_points[1] - 1;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,fac2,k,m) firstprivate (j,n,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac2)
for (m = 0; m <= 2; m += 1) {
rhs[m][i][j1][k] = fac2 * rhs[m][i][j1][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,i,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,k,m) firstprivate (j,n,j1) | 100 | mp parallel for private (fac1,fac2,i,k,m)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac2)
for (m = 0; m <= 2; m += 1) {
rhs[m][i][j1][k] = fac2 * rhs[m][i][j1][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,k,m) firstprivate (j,n,j1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac1) | 100 | k] = fac1 * lhs[n + 3][i][j][k];
lhs[n + 4][i][j][k] = fac1 * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k] = fac1 * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) | 100 | lhs[n + 3][i][j1][k] = lhs[n + 3][i][j1][k] - lhs[n + 1][i][j1][k] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j1][k] = rhs[m][i][j1][k] - lhs[n + 1][i][j1][k] * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac2) | 100 | ----------------------------------------------*/
fac2 = 1. / lhs[n + 2][i][j1][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j1][k] = fac2 * rhs[m][i][j1][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,i,k) | 100 | for (j = 0; j <= grid_points[1] - 3; j += 1) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,k) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (fac1,i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,k) firstprivate (n,j1,j2) | 100 | p parallel for private (fac1,i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (fac1,k) firstprivate (n,j1,j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,i,k) | 100 | -----------------------------*/
j = grid_points[1] - 2;
j1 = grid_points[1] - 1;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,fac2,k) firstprivate (j,n,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,k) firstprivate (j,n,j1) | 100 | parallel for private (fac1,fac2,i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,k) firstprivate (j,n,j1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,k,m) | 100 | ------------------------*/
j = grid_points[1] - 2;
j1 = grid_points[1] - 1;
n = 0;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
#pragma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (j,n,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (i,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,k) | 100 | ;
n = 0;
#pragma omp parallel for private (i,k,m)
for (m = 0; m <= 2; m += 1) {
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (j,n,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (j,n,j1) | 100 | pragma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (j,n,j1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,i,k,m) | 100 | ][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 <= 4; m += 1) {
#pragma omp parallel for private (n,i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (n,k) firstprivate (j,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,i,k) | 100 | }
}
#pragma omp parallel for private (n,i,k,m)
for (m = 3; m <= 4; m += 1) {
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (n,k) firstprivate (j,j1)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,k) firstprivate (j,j1) | 100 | agma omp parallel for private (n,i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,k) firstprivate (j,j1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j1,j2,i,j,k,m) | 100 | hree factors
--------------------------------------------------------------------*/
n = 0;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
for (j = grid_points[1] - 3; j >= 0; j += -1) {
j1 = j + 1;
j2 = j + 2;
#pragma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,k) | 100 | for (j = grid_points[1] - 3; j >= 0; j += -1) {
j1 = j + 1;
j2 = j + 2;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (n,j1,j2) | 100 | ma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (n,j1,j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,j1,j2,i,j,k,m) | 100 | And the remaining two
--------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
for (j = grid_points[1] - 3; j >= 0; j += -1) {
j1 = j + 1;
j2 = j1 + 1;
#pragma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,k) | 100 | for (j = grid_points[1] - 3; j >= 0; j += -1) {
j1 = j + 1;
j2 = j1 + 1;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k) firstprivate (n,j1,j2)
for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (i,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k) firstprivate (n,j1,j2) | 100 | ma omp parallel for private (i,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (k = 1; k <= grid_points[2] - 2; k += 1) {
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 (k) firstprivate (n,j1,j2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,fac1,i,j,k,m) | 100 |
c-------------------------------------------------------------------*/
lhsz();
n = 0;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,fac1,j,k,m)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = 0; k <= grid_points[2] - 3; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (k1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (k2)
for (m = 0; m <= 2; m += 1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,fac1,j,k,m) | 100 | parallel for private (k1,k2,fac1,i,j,k,m)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = 0; k <= grid_points[2] - 3; k += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (k1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (k2)
for (m = 0; m <= 2; m += 1) {
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,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac1) | 100 | fac1 * lhs[n + 3][i][j][k];
lhs[n + 4][i][j][k] = fac1 * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k] = fac1 * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (k1) | 100 | hs[n + 3][i][j][k1] = lhs[n + 3][i][j][k1] - lhs[n + 1][i][j][k1] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] - lhs[n + 1][i][j][k1] * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (k1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (k2) | 100 | hs[n + 2][i][j][k2] = lhs[n + 2][i][j][k2] - lhs[n + 0][i][j][k2] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
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 (m) firstprivate (k2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,i,j,m) | 100 | -----------------------------------*/
k = grid_points[2] - 2;
k1 = grid_points[2] - 1;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,fac2,j,m) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac2)
for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k1] = fac2 * rhs[m][i][j][k1];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,i,j,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,j,m) firstprivate (k,n,k1) | 100 | mp parallel for private (fac1,fac2,i,j,m)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac1)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m)
for (m = 0; m <= 2; m += 1) {
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];
#pragma omp parallel for private (m) firstprivate (fac2)
for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k1] = fac2 * rhs[m][i][j][k1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (fac1,fac2,j,m) firstprivate (k,n,k1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac1) | 100 | k] = fac1 * lhs[n + 3][i][j][k];
lhs[n + 4][i][j][k] = fac1 * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k] = fac1 * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) | 100 | lhs[n + 3][i][j][k1] = lhs[n + 3][i][j][k1] - lhs[n + 1][i][j][k1] * lhs[n + 4][i][j][k];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k1] = rhs[m][i][j][k1] - lhs[n + 1][i][j][k1] * rhs[m][i][j][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (m) firstprivate (fac2) | 100 | ----------------------------------------------*/
fac2 = 1. / lhs[n + 2][i][j][k1];
<LOOP-START>for (m = 0; m <= 2; m += 1) {
rhs[m][i][j][k1] = fac2 * rhs[m][i][j][k1];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (m) firstprivate (fac2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,fac1,i,j,k) | 100 | -----------------------------*/
for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,fac1,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = 0; k <= grid_points[2] - 3; k += 1) {
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,i,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,fac1,j,k) | 100 | rallel for private (k1,k2,fac1,i,j,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = 0; k <= grid_points[2] - 3; k += 1) {
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,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,i,j) | 100 | -----------------------------*/
k = grid_points[2] - 2;
k1 = grid_points[2] - 1;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (fac1,fac2,j) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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,i,j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (fac1,fac2,j) firstprivate (k,n,k1) | 100 | parallel for private (fac1,fac2,i,j)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
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,j) firstprivate (k,n,k1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,j,m) | 100 | ------------------------*/
k = grid_points[2] - 2;
k1 = grid_points[2] - 1;
n = 0;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
#pragma omp parallel for private (i,j)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (j) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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 (i,j,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,j) | 100 | ;
n = 0;
#pragma omp parallel for private (i,j,m)
for (m = 0; m <= 2; m += 1) {
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (j) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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 (i,j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j) firstprivate (k,n,k1) | 100 | pragma omp parallel for private (i,j)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
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 (j) firstprivate (k,n,k1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,i,j,m) | 100 | ][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 <= 4; m += 1) {
n = (m - 3 + 1) * 5;
#pragma omp parallel for private (i,j)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (j) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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,i,j,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (i,j) | 100 | parallel for private (n,i,j,m)
for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (j) firstprivate (k,n,k1)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
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 (i,j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (j) firstprivate (k,n,k1) | 100 | pragma omp parallel for private (i,j)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
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 (j) firstprivate (k,n,k1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,i,j,k,m) | 100 | hree factors
c-------------------------------------------------------------------*/
n = 0;
<LOOP-START>for (m = 0; m <= 2; m += 1) {
#pragma omp parallel for private (k1,k2,i,j,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,i,j,k) | 100 | = 0;
#pragma omp parallel for private (k1,k2,i,j,k,m)
for (m = 0; m <= 2; m += 1) {
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,i,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,j,k) | 100 | mp parallel for private (k1,k2,i,j,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (n,k1,k2,i,j,k,m) | 100 | And the remaining two
c-------------------------------------------------------------------*/
<LOOP-START>for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
#pragma omp parallel for private (k1,k2,i,j,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,i,j,k,m)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,i,j,k) | 100 | l for private (n,k1,k2,i,j,k,m)
for (m = 3; m <= 4; m += 1) {
n = (m - 3 + 1) * 5;
<LOOP-START>for (i = 1; i <= grid_points[0] - 2; i += 1) {
#pragma omp parallel for private (k1,k2,j,k)
for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,i,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for private (k1,k2,j,k) | 100 | mp parallel for private (k1,k2,i,j,k)
for (i = 1; i <= grid_points[0] - 2; i += 1) {
<LOOP-START>for (j = 1; j <= grid_points[1] - 2; j += 1) {
for (k = grid_points[2] - 3; k >= 0; k += -1) {
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,j,k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (j) | 100 | .0 structured OpenMP C version - EP Benchmark\n");
sprintf(size,"%12.0f",(pow(2.0,(28 + 1))));
<LOOP-START>for (j = 13; j >= 1; j += -1) {
if (size[j] == '.')
size[j] = ' ';
}<LOOP-END> <OMP-START>#pragma omp parallel for private (j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (i) | 100 | iminated as dead code.
*/
vranlc(0,&dum[0],dum[1],&dum[2]);
dum[0] = randlc(&dum[1],dum[2]);
<LOOP-START>for (i = 0; i <= 131071; i += 1) {
x[i] = - 1.0e99;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (i) | 100 |
t2 = randlc(&t1,t1);
}
an = t1;
tt = 271828183.0;
gc = 0.0;
sx = 0.0;
sy = 0.0;
<LOOP-START>for (i = 0; i <= 9; i += 1) {
q[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (i) | 100 | int kk;
int i;
int ik;
int l;
/* private copy of q[0:NQ-1] */
double qq[10];
<LOOP-START>for (i = 0; i <= 9; i += 1) {
qq[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/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 |
#pragma omp parallel for private (i)
for (i = 0; i <= 9; i += 1) {
qq[i] = 0.0;
}
//<LOOP-START>for (k = 1; k <= np; k += 1) {
kk = k_offset + k;
t1 = 271828183.0;
t2 = an;
/* Find starting seed t1 for this kk. */
for (i = 1; i <= 100; i += 1) {
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 (0 == 1)
timer_start(3);
vranlc(2 * (1 << 16),&t1,1220703125.0,x - 1);
if (0 == 1)
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 (0 == 1)
timer_start(2);
for (i = 0; i <= 65535; i += 1) {
x1 = 2.0 * x[2 * i] - 1.0;
x2 = 2.0 * x[2 * i + 1] - 1.0;
t1 = x1 * x1 + x2 * x2;
if (t1 <= 1.0) {
t2 = sqrt(- 2.0 * log(t1) / t1);
/* Xi */
t3 = x1 * t2;
/* Yi */
t4 = x2 * t2;
l = ((fabs(t3) > fabs(t4)?fabs(t3) : fabs(t4)));
/* counts */
qq[l] += 1.0;
/* sum of Xi */
sx = sx + t3;
/* sum of Yi */
sy = sy + t4;
}
}
if (0 == 1)
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/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (i) | 100 |
sy = sy + t4;
}
}
if (0 == 1)
timer_stop(2);
}
{
<LOOP-START>for (i = 0; i <= 9; i += 1) {
q[i] += qq[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/EP/ep.c | #pragma omp parallel for private (i) reduction (+:gc) | 100 | nthreads = omp_get_num_threads();
//#endif /* _OPENMP */
/* end of parallel region */
}
<LOOP-START>for (i = 0; i <= 9; i += 1) {
gc = gc + q[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) reduction (+:gc)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i) | 100 | d defaults\n");
lt = 8;
nit = 4;
nx[lt] = 256;
ny[lt] = 256;
nz[lt] = 256;
<LOOP-START>for (i = 0; i <= 7; i += 1) {
debug_vec[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (k) | 100 | k += -1) {
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 += 1) {
m1[k] = nx[k] + 2;
m2[k] = nz[k] + 2;
m3[k] = ny[k] + 2;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (k)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2,i3) firstprivate (n3) | 100 | ---------------------------------------------*/
int i1;
int i2;
int i3;
/* axis = 1 */
{
<LOOP-START>for (i3 = 1; i3 <= n3 - 1 - 1; i3 += 1) {
#pragma omp parallel for private (i2)
for (i2 = 1; i2 <= n2 - 1 - 1; i2 += 1) {
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) firstprivate (n3)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i2) | 100 | allel for private (i1,i2,i3) firstprivate (n3)
for (i3 = 1; i3 <= n3 - 1 - 1; i3 += 1) {
<LOOP-START>for (i2 = 1; i2 <= n2 - 1 - 1; i2 += 1) {
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 (i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1) | 100 | 2];
}
// }
/* axis = 2 */
//#pragma omp for
// for ( i3 = 1; i3 < n3-1; i3++) {
<LOOP-START>for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
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 private (i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2) firstprivate (n1,n2) | 100 | 1][i1] = u[i3][1][i1];
u[i3][0][i1] = u[i3][n2 - 2][i1];
}
}
/* axis = 3 */
<LOOP-START>for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
#pragma omp parallel for private (i1) firstprivate (n3)
for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
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) firstprivate (n1,n2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1) firstprivate (n3) | 100 | parallel for private (i1,i2) firstprivate (n1,n2)
for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
<LOOP-START>for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
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) firstprivate (n3)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i) | 100 | oks for twenty candidates
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 0; i <= 9; i += 1) {
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 private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2,i3) | 100 | r\n");
for (i = MM-1; i >= 0; i--) {
printf(" %4d", jg[0][i][1]);
}
printf("\n");*/
<LOOP-START>for (i3 = 0; i3 <= n3 - 1; i3 += 1) {
#pragma omp parallel for private (i1,i2)
for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
#pragma omp parallel for private (i1)
for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1,i2,i3)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2) | 100 | \n");*/
#pragma omp parallel for private (i1,i2,i3)
for (i3 = 0; i3 <= n3 - 1; i3 += 1) {
<LOOP-START>for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
#pragma omp parallel for private (i1)
for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1,i2)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1) | 100 | 1) {
#pragma omp parallel for private (i1,i2)
for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
<LOOP-START>for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2,i3) firstprivate (n2,n3) | 100 | ----------------------------------------------------------------*/
int i1;
int i2;
int i3;
<LOOP-START>for (i3 = 0; i3 <= n3 - 1; i3 += 1) {
#pragma omp parallel for private (i1,i2) firstprivate (n1)
for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
#pragma omp parallel for private (i1)
for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1,i2,i3) firstprivate (n2,n3)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1,i2) firstprivate (n1) | 100 | p parallel for private (i1,i2,i3) firstprivate (n2,n3)
for (i3 = 0; i3 <= n3 - 1; i3 += 1) {
<LOOP-START>for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
#pragma omp parallel for private (i1)
for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1,i2) firstprivate (n1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/MG/mg.c | #pragma omp parallel for private (i1) | 100 | omp parallel for private (i1,i2) firstprivate (n1)
for (i2 = 0; i2 <= n2 - 1; i2 += 1) {
<LOOP-START>for (i1 = 0; i1 <= n1 - 1; i1 += 1) {
z[i3][i2][i1] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i1)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) reduction (*:R23,T23) | 100 | int i;
int j;
if (KS == 0) {
R23 = 1.0;
R46 = 1.0;
T23 = 1.0;
T46 = 1.0;
<LOOP-START>for (i = 1; i <= 23; i += 1) {
R23 = 0.50 * R23;
T23 = 2.0 * T23;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) reduction (*:R23,T23)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) reduction (*:R46,T46) | 100 | 3,T23)
for (i = 1; i <= 23; i += 1) {
R23 = 0.50 * R23;
T23 = 2.0 * T23;
}
<LOOP-START>for (i = 1; i <= 46; i += 1) {
R46 = 0.50 * R46;
T46 = 2.0 * T46;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) reduction (*:R46,T46)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) reduction (+:j) | 100 | ff2[i];
}
/* Confirm keys correctly sorted: count incorrectly sorted keys, if any */
j = 0;
<LOOP-START>for (i = 1; i <= 8388607; i += 1) {
if (key_array[i - 1] > key_array[i])
j++;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i) reduction (+:j)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) | 100 | st keys are, load into */
/* top of array bucket_size */
<LOOP-START>for (i = 0; i <= 4; i += 1) {
partial_verify_vals[i] = key_array[test_index_array[i]];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) | 100 | partial_verify_vals[i] = key_array[test_index_array[i]];
}
/* Clear the work array */
<LOOP-START>for (i = 0; i <= 524287; i += 1) {
key_buff1[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) | 100 | arallel for private (i)
for (i = 0; i <= 524287; i += 1) {
key_buff1[i] = 0;
}
}
<LOOP-START>for (i = 0; i <= 524287; i += 1) {
prv_buff1[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) | 100 | */
for (i = 0; i <= 524286; i += 1) {
prv_buff1[i + 1] += prv_buff1[i];
}
{
<LOOP-START>for (i = 0; i <= 524287; i += 1) {
key_buff1[i] += prv_buff1[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/Autopar/NPB3.0-omp-c/IS/is.c | #pragma omp parallel for private (i) | 100 | double timecounter;
double maxtime;
/* Initialize the verification arrays if a valid class */
<LOOP-START>for (i = 0; i <= 4; i += 1) {
switch('A'){
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/Cetus/dataracebench/DRB009-lastprivatemissing-orig-yes.c | #pragma omp parallel for private(i) lastprivate(x) | 100 | tus private(i)
#pragma cetus lastprivate(x)
#pragma loop name main#0
#pragma cetus parallel
<LOOP-START>for (i=0; i<len; i ++ )
{
x=i;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) lastprivate(x)<OMP-END> |
LLNL/AutoParBench/benchmarks/Cetus/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private(i, j) | 100 | int _ret_val_0;
#pragma cetus private(i, j)
#pragma loop name main#0
#pragma cetus parallel
<LOOP-START>for (i=0; i<len; i ++ )
{
#pragma cetus private(j)
#pragma loop name main#0#0
#pragma cetus parallel
#pragma omp parallel for private(j)
for (j=0; j<len; j ++ )
{
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.