filename
stringlengths 78
241
| omp_pragma_line
stringlengths 24
416
| context_chars
int64 100
100
| text
stringlengths 152
177k
|
|---|---|---|---|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu_double.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
d dealloc(T* array)
{
delete[] array;
}
template <typename T>
void copy(T* dst, T* src, int N)
{
<LOOP-START>for(int i = 0; i < N; i++)
{
dst[i] = src[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu_double.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
e3 ff_flux_contribution_density_energy;
void initialize_variables(int nelr, double* variables)
{
<LOOP-START>for(int i = 0; i < nelr; i++)
{
for(int j = 0; j < NVAR; j++) variables[i*NVAR + j] = ff_variable[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu_double.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
}
void compute_step_factor(int nelr, double* variables, double* areas, double* step_factors)
{
<LOOP-START>for(int i = 0; i < nelr; i++)
{
double density = variables[NVAR*i + VAR_DENSITY];
double3 momentum;
momentum.x = variables[NVAR*i + (VAR_MOMENTUM+0)];
momentum.y = variables[NVAR*i + (VAR_MOMENTUM+1)];
momentum.z = variables[NVAR*i + (VAR_MOMENTUM+2)];
double density_energy = variables[NVAR*i + VAR_DENSITY_ENERGY];
double3 velocity; compute_velocity(density, momentum, velocity);
double speed_sqd = compute_speed_sqd(velocity);
double pressure = compute_pressure(density, density_energy, speed_sqd);
double speed_of_sound = compute_speed_of_sound(density, pressure);
// dt = double(0.5) * std::sqrt(areas[i]) / (||v|| + c).... but when we do time stepping, this later would need to be divided by the area, so we just do it all at once
step_factors[i] = double(0.5) / (std::sqrt(areas[i]) * (std::sqrt(speed_sqd) + speed_of_sound));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu_double.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
normals, double* variables, double* fluxes)
{
const double smoothing_coefficient = double(0.2f);
<LOOP-START>for(int i = 0; i < nelr; i++)
{
int j, nb;
double3 normal; double normal_len;
double factor;
double density_i = variables[NVAR*i + VAR_DENSITY];
double3 momentum_i;
momentum_i.x = variables[NVAR*i + (VAR_MOMENTUM+0)];
momentum_i.y = variables[NVAR*i + (VAR_MOMENTUM+1)];
momentum_i.z = variables[NVAR*i + (VAR_MOMENTUM+2)];
double density_energy_i = variables[NVAR*i + VAR_DENSITY_ENERGY];
double3 velocity_i; compute_velocity(density_i, momentum_i, velocity_i);
double speed_sqd_i = compute_speed_sqd(velocity_i);
double speed_i = std::sqrt(speed_sqd_i);
double pressure_i = compute_pressure(density_i, density_energy_i, speed_sqd_i);
double speed_of_sound_i = compute_speed_of_sound(density_i, pressure_i);
double3 flux_contribution_i_momentum_x, flux_contribution_i_momentum_y, flux_contribution_i_momentum_z;
double3 flux_contribution_i_density_energy;
compute_flux_contribution(density_i, momentum_i, density_energy_i, pressure_i, velocity_i, flux_contribution_i_momentum_x, flux_contribution_i_momentum_y, flux_contribution_i_momentum_z, flux_contribution_i_density_energy);
double flux_i_density = double(0.0);
double3 flux_i_momentum;
flux_i_momentum.x = double(0.0);
flux_i_momentum.y = double(0.0);
flux_i_momentum.z = double(0.0);
double flux_i_density_energy = double(0.0);
double3 velocity_nb;
double density_nb, density_energy_nb;
double3 momentum_nb;
double3 flux_contribution_nb_momentum_x, flux_contribution_nb_momentum_y, flux_contribution_nb_momentum_z;
double3 flux_contribution_nb_density_energy;
double speed_sqd_nb, speed_of_sound_nb, pressure_nb;
for(j = 0; j < NNB; j++)
{
nb = elements_surrounding_elements[i*NNB + j];
normal.x = normals[(i*NNB + j)*NDIM + 0];
normal.y = normals[(i*NNB + j)*NDIM + 1];
normal.z = normals[(i*NNB + j)*NDIM + 2];
normal_len = std::sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z);
if(nb >= 0) // a legitimate neighbor
{
density_nb = variables[nb*NVAR + VAR_DENSITY];
momentum_nb.x = variables[nb*NVAR + (VAR_MOMENTUM+0)];
momentum_nb.y = variables[nb*NVAR + (VAR_MOMENTUM+1)];
momentum_nb.z = variables[nb*NVAR + (VAR_MOMENTUM+2)];
density_energy_nb = variables[nb*NVAR + VAR_DENSITY_ENERGY];
compute_velocity(density_nb, momentum_nb, velocity_nb);
speed_sqd_nb = compute_speed_sqd(velocity_nb);
pressure_nb = compute_pressure(density_nb, density_energy_nb, speed_sqd_nb);
speed_of_sound_nb = compute_speed_of_sound(density_nb, pressure_nb);
compute_flux_contribution(density_nb, momentum_nb, density_energy_nb, pressure_nb, velocity_nb, flux_contribution_nb_momentum_x, flux_contribution_nb_momentum_y, flux_contribution_nb_momentum_z, flux_contribution_nb_density_energy);
// artificial viscosity
factor = -normal_len*smoothing_coefficient*double(0.5)*(speed_i + std::sqrt(speed_sqd_nb) + speed_of_sound_i + speed_of_sound_nb);
flux_i_density += factor*(density_i-density_nb);
flux_i_density_energy += factor*(density_energy_i-density_energy_nb);
flux_i_momentum.x += factor*(momentum_i.x-momentum_nb.x);
flux_i_momentum.y += factor*(momentum_i.y-momentum_nb.y);
flux_i_momentum.z += factor*(momentum_i.z-momentum_nb.z);
// accumulate cell-centered fluxes
factor = double(0.5)*normal.x;
flux_i_density += factor*(momentum_nb.x+momentum_i.x);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.x+flux_contribution_i_density_energy.x);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.x+flux_contribution_i_momentum_x.x);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.x+flux_contribution_i_momentum_y.x);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.x+flux_contribution_i_momentum_z.x);
factor = double(0.5)*normal.y;
flux_i_density += factor*(momentum_nb.y+momentum_i.y);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.y+flux_contribution_i_density_energy.y);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.y+flux_contribution_i_momentum_x.y);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.y+flux_contribution_i_momentum_y.y);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.y+flux_contribution_i_momentum_z.y);
factor = double(0.5)*normal.z;
flux_i_density += factor*(momentum_nb.z+momentum_i.z);
flux_i_density_energy += factor*(flux_contribution_nb_density_energy.z+flux_contribution_i_density_energy.z);
flux_i_momentum.x += factor*(flux_contribution_nb_momentum_x.z+flux_contribution_i_momentum_x.z);
flux_i_momentum.y += factor*(flux_contribution_nb_momentum_y.z+flux_contribution_i_momentum_y.z);
flux_i_momentum.z += factor*(flux_contribution_nb_momentum_z.z+flux_contribution_i_momentum_z.z);
}
else if(nb == -1) // a wing boundary
{
flux_i_momentum.x += normal.x*pressure_i;
flux_i_momentum.y += normal.y*pressure_i;
flux_i_momentum.z += normal.z*pressure_i;
}
else if(nb == -2) // a far field boundary
{
factor = double(0.5)*normal.x;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+0]+momentum_i.x);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.x+flux_contribution_i_density_energy.x);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.x + flux_contribution_i_momentum_x.x);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.x + flux_contribution_i_momentum_y.x);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.x + flux_contribution_i_momentum_z.x);
factor = double(0.5)*normal.y;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+1]+momentum_i.y);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.y+flux_contribution_i_density_energy.y);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.y + flux_contribution_i_momentum_x.y);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.y + flux_contribution_i_momentum_y.y);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.y + flux_contribution_i_momentum_z.y);
factor = double(0.5)*normal.z;
flux_i_density += factor*(ff_variable[VAR_MOMENTUM+2]+momentum_i.z);
flux_i_density_energy += factor*(ff_flux_contribution_density_energy.z+flux_contribution_i_density_energy.z);
flux_i_momentum.x += factor*(ff_flux_contribution_momentum_x.z + flux_contribution_i_momentum_x.z);
flux_i_momentum.y += factor*(ff_flux_contribution_momentum_y.z + flux_contribution_i_momentum_y.z);
flux_i_momentum.z += factor*(ff_flux_contribution_momentum_z.z + flux_contribution_i_momentum_z.z);
}
}
fluxes[i*NVAR + VAR_DENSITY] = flux_i_density;
fluxes[i*NVAR + (VAR_MOMENTUM+0)] = flux_i_momentum.x;
fluxes[i*NVAR + (VAR_MOMENTUM+1)] = flux_i_momentum.y;
fluxes[i*NVAR + (VAR_MOMENTUM+2)] = flux_i_momentum.z;
fluxes[i*NVAR + VAR_DENSITY_ENERGY] = flux_i_density_energy;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/cfd/euler3d_cpu_double.cpp
|
#pragma omp parallel for default(shared) schedule(static)
| 100
|
int j, int nelr, double* old_variables, double* variables, double* step_factors, double* fluxes)
{
<LOOP-START>for(int i = 0; i < nelr; i++)
{
double factor = step_factors[i]/double(RK+1-j);
variables[NVAR*i + VAR_DENSITY] = old_variables[NVAR*i + VAR_DENSITY] + factor*fluxes[NVAR*i + VAR_DENSITY];
variables[NVAR*i + VAR_DENSITY_ENERGY] = old_variables[NVAR*i + VAR_DENSITY_ENERGY] + factor*fluxes[NVAR*i + VAR_DENSITY_ENERGY];
variables[NVAR*i + (VAR_MOMENTUM+0)] = old_variables[NVAR*i + (VAR_MOMENTUM+0)] + factor*fluxes[NVAR*i + (VAR_MOMENTUM+0)];
variables[NVAR*i + (VAR_MOMENTUM+1)] = old_variables[NVAR*i + (VAR_MOMENTUM+1)] + factor*fluxes[NVAR*i + (VAR_MOMENTUM+1)];
variables[NVAR*i + (VAR_MOMENTUM+2)] = old_variables[NVAR*i + (VAR_MOMENTUM+2)] + factor*fluxes[NVAR*i + (VAR_MOMENTUM+2)];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/hotspot/hotspot_openmp.cpp
|
#pragma omp parallel for shared(power, temp, result) private(chunk, r, c, delta) firstprivate(row, col, num_chunk, chunks_in_row) schedule(static)
| 100
|
LOCK_SIZE_R;
#ifdef OPEN
#ifndef __MIC__
omp_set_num_threads(num_omp_threads);
#endif
<LOOP-START>for ( chunk = 0; chunk < num_chunk; ++chunk )
{
int r_start = BLOCK_SIZE_R*(chunk/chunks_in_col);
int c_start = BLOCK_SIZE_C*(chunk%chunks_in_row);
int r_end = r_start + BLOCK_SIZE_R > row ? row : r_start + BLOCK_SIZE_R;
int c_end = c_start + BLOCK_SIZE_C > col ? col : c_start + BLOCK_SIZE_C;
if ( r_start == 0 || c_start == 0 || r_end == row || c_end == col )
{
for ( r = r_start; r < r_start + BLOCK_SIZE_R; ++r ) {
for ( c = c_start; c < c_start + BLOCK_SIZE_C; ++c ) {
/* Corner 1 */
if ( (r == 0) && (c == 0) ) {
delta = (Cap_1) * (power[0] +
(temp[1] - temp[0]) * Rx_1 +
(temp[col] - temp[0]) * Ry_1 +
(amb_temp - temp[0]) * Rz_1);
} /* Corner 2 */
else if ((r == 0) && (c == col-1)) {
delta = (Cap_1) * (power[c] +
(temp[c-1] - temp[c]) * Rx_1 +
(temp[c+col] - temp[c]) * Ry_1 +
( amb_temp - temp[c]) * Rz_1);
} /* Corner 3 */
else if ((r == row-1) && (c == col-1)) {
delta = (Cap_1) * (power[r*col+c] +
(temp[r*col+c-1] - temp[r*col+c]) * Rx_1 +
(temp[(r-1)*col+c] - temp[r*col+c]) * Ry_1 +
( amb_temp - temp[r*col+c]) * Rz_1);
} /* Corner 4 */
else if ((r == row-1) && (c == 0)) {
delta = (Cap_1) * (power[r*col] +
(temp[r*col+1] - temp[r*col]) * Rx_1 +
(temp[(r-1)*col] - temp[r*col]) * Ry_1 +
(amb_temp - temp[r*col]) * Rz_1);
} /* Edge 1 */
else if (r == 0) {
delta = (Cap_1) * (power[c] +
(temp[c+1] + temp[c-1] - 2.0*temp[c]) * Rx_1 +
(temp[col+c] - temp[c]) * Ry_1 +
(amb_temp - temp[c]) * Rz_1);
} /* Edge 2 */
else if (c == col-1) {
delta = (Cap_1) * (power[r*col+c] +
(temp[(r+1)*col+c] + temp[(r-1)*col+c] - 2.0*temp[r*col+c]) * Ry_1 +
(temp[r*col+c-1] - temp[r*col+c]) * Rx_1 +
(amb_temp - temp[r*col+c]) * Rz_1);
} /* Edge 3 */
else if (r == row-1) {
delta = (Cap_1) * (power[r*col+c] +
(temp[r*col+c+1] + temp[r*col+c-1] - 2.0*temp[r*col+c]) * Rx_1 +
(temp[(r-1)*col+c] - temp[r*col+c]) * Ry_1 +
(amb_temp - temp[r*col+c]) * Rz_1);
} /* Edge 4 */
else if (c == 0) {
delta = (Cap_1) * (power[r*col] +
(temp[(r+1)*col] + temp[(r-1)*col] - 2.0*temp[r*col]) * Ry_1 +
(temp[r*col+1] - temp[r*col]) * Rx_1 +
(amb_temp - temp[r*col]) * Rz_1);
}
result[r*col+c] =temp[r*col+c]+ delta;
}
}
continue;
}
for ( r = r_start; r < r_start + BLOCK_SIZE_R; ++r ) {
#pragma omp simd
for ( c = c_start; c < c_start + BLOCK_SIZE_C; ++c ) {
/* Update Temperatures */
result[r*col+c] =temp[r*col+c]+
( Cap_1 * (power[r*col+c] +
(temp[(r+1)*col+c] + temp[(r-1)*col+c] - 2.f*temp[r*col+c]) * Ry_1 +
(temp[r*col+c+1] + temp[r*col+c-1] - 2.f*temp[r*col+c]) * Rx_1 +
(amb_temp - temp[r*col+c]) * Rz_1));
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(power, temp, result) private(chunk, r, c, delta) firstprivate(row, col, num_chunk, chunks_in_row) schedule(static)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/rodinia_3.1/openmp/heartwall/main.c
|
#pragma omp parallel for
| 100
|
====================================================
omp_set_num_threads(omp_num_threads);
<LOOP-START>for(i=0; i<public.allPoints; i++){
kernel( public,
private[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12)
| 100
|
---------------------------------------------------------*/
norm_temp11 = 0.0;
norm_temp12 = 0.0;
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
norm_temp11 = norm_temp11 + x[j]*z[j];
norm_temp12 = norm_temp12 + z[j]*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(j)
| 100
|
-
c Normalize z to obtain x
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
x[j] = norm_temp12*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(i)
| 100
|
ing vector to (1, 1, .... 1)
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 1; i <= NA+1; i++) {
x[i] = 1.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12)
| 100
|
--------------------------------------------------------*/
norm_temp11 = 0.0;
norm_temp12 = 0.0;
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
norm_temp11 = norm_temp11 + x[j]*z[j];
norm_temp12 = norm_temp12 + z[j]*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j) reduction(+:norm_temp11,norm_temp12)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(j)
| 100
|
-
c Normalize z to obtain x
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= lastcol-firstcol+1; j++) {
x[j] = norm_temp12*z[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(i)
| 100
|
to mark nonzero positions
c---------------------------------------------------------------------*/
<LOOP-START>for (i = 1; i <= n; i++) {
colidx[n+i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(j)
| 100
|
umber of triples in each row
c-------------------------------------------------------------------*/
<LOOP-START>for (j = 1; j <= n; j++) {
rowstr[j] = 0;
mark[j] = FALSE;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(k,j)
| 100
|
... preload data pages
c---------------------------------------------------------------------*/
<LOOP-START>for(j = 0;j <= nrows-1;j++) {
for(k = rowstr[j];k <= rowstr[j+1]-1;k++)
a[k] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(k,j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/CG/cg.c
|
#pragma omp parallel for default(shared) private(i)
| 100
|
adding elements
c-------------------------------------------------------------------*/
nza = 0;
<LOOP-START>for (i = 1; i <= n; i++) {
x[i] = 0.0;
mark[i] = FALSE;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/FT/ft.c
|
#pragma omp parallel for default(shared) private(i,j,k)
| 100
|
ier space
c-------------------------------------------------------------------*/
int i, j, k;
<LOOP-START>for (k = 0; k < d[2]; k++) {
for (j = 0; j < d[1]; j++) {
for (i = 0; i < d[0]; i++) {
crmul(u1[k][j][i], u0[k][j][i], ex[t*indexmap[k][j][i]]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/FT/ft.c
|
#pragma omp parallel for default(shared) private(i,j,k,ii,ii2,jj,ij2,kk)
| 100
|
ck:
c mod(i-1+n/2, n) - n/2
c-------------------------------------------------------------------*/
<LOOP-START>for (i = 0; i < dims[2][0]; i++) {
ii = (i+1+xstart[2]-2+NX/2)%NX - NX/2;
ii2 = ii*ii;
for (j = 0; j < dims[2][1]; j++) {
jj = (j+1+ystart[2]-2+NY/2)%NY - NY/2;
ij2 = jj*jj+ii2;
for (k = 0; k < dims[2][2]; k++) {
kk = (k+1+zstart[2]-2+NZ/2)%NZ - NZ/2;
indexmap[k][j][i] = kk*kk+ij2;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,ii,ii2,jj,ij2,kk) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)
| 100
|
--------------------------------------------*/
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 1; k <= grid_points[2]-2; k++) {
r1 = rhs[0][i][j][k];
r2 = rhs[1][i][j][k];
r3 = rhs[2][i][j][k];
r4 = rhs[3][i][j][k];
r5 = rhs[4][i][j][k];
t1 = bt * r3;
t2 = 0.5 * ( r4 + r5 );
rhs[0][i][j][k] = -r2;
rhs[1][i][j][k] = r1;
rhs[2][i][j][k] = bt * ( r4 - r5 );
rhs[3][i][j][k] = -t1 + t2;
rhs[4][i][j][k] = t1 + t2;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/SP/sp.c
|
#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)
| 100
|
-------------------------------------------*/
int i, j, k;
double r1, r2, r3, r4, r5, t1, t2;
<LOOP-START>for (i = 1; i <= grid_points[0]-2; i++) {
for (j = 1; j <= grid_points[1]-2; j++) {
for (k = 1; k <= grid_points[2]-2; k++) {
r1 = rhs[0][i][j][k];
r2 = rhs[1][i][j][k];
r3 = rhs[2][i][j][k];
r4 = rhs[3][i][j][k];
r5 = rhs[4][i][j][k];
t1 = bt * r1;
t2 = 0.5 * ( r4 + r5 );
rhs[0][i][j][k] = bt * ( r4 - r5 );
rhs[1][i][j][k] = -r3;
rhs[2][i][j][k] = r2;
rhs[3][i][j][k] = -t1 + t2;
rhs[4][i][j][k] = t1 + t2;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i,j,k,r1,r2,r3,r4,r5,t1,t2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/EP/ep.c
|
#pragma omp parallel for default(shared) private(i)
| 100
|
code.
*/
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 default(shared) private(i)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for default(shared) 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++) {
for (i1 = 0; i1 < n1; i1++) {
r1[i1] = r[i3][i2-1][i1] + r[i3][i2+1][i1]
+ r[i3-1][i2][i1] + r[i3+1][i2][i1];
r2[i1] = r[i3-1][i2-1][i1] + r[i3-1][i2+1][i1]
+ r[i3+1][i2-1][i1] + r[i3+1][i2+1][i1];
}
for (i1 = 1; i1 < n1-1; i1++) {
u[i3][i2][i1] = u[i3][i2][i1]
+ c[0] * r[i3][i2][i1]
+ c[1] * ( r[i3][i2][i1-1] + r[i3][i2][i1+1]
+ r1[i1] )
+ c[2] * ( r2[i1] + r1[i1-1] + r1[i1+1] );
/*--------------------------------------------------------------------
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 default(shared) private(i1,i2,i3,r1,r2) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for default(shared) 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++) {
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 default(shared) private(i1,i2,i3,u1,u2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for default(shared) private(j1,j2,j3,i1,i2,i3,x1,y1,x2,y2)
| 100
|
lse {
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*/
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 default(shared) private(j1,j2,j3,i1,i2,i3,x1,y1,x2,y2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for default(shared) private(i1,i2,i3,z1,z2,z3)
| 100
|
parameter( m=535 )
*/
double z1[M], z2[M], z3[M];
if ( n1 != 3 && n2 != 3 && n3 != 3 ) {
<LOOP-START>for (i3 = 0; i3 < mm3-1; i3++) {
for (i2 = 0; i2 < mm2-1; i2++) {
for (i1 = 0; i1 < mm1; i1++) {
z1[i1] = z[i3][i2+1][i1] + z[i3][i2][i1];
z2[i1] = z[i3+1][i2][i1] + z[i3][i2][i1];
z3[i1] = z[i3+1][i2+1][i1] + z[i3+1][i2][i1] + z1[i1];
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3][2*i2][2*i1] = u[2*i3][2*i2][2*i1]
+z[i3][i2][i1];
u[2*i3][2*i2][2*i1+1] = u[2*i3][2*i2][2*i1+1]
+0.5*(z[i3][i2][i1+1]+z[i3][i2][i1]);
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3][2*i2+1][2*i1] = u[2*i3][2*i2+1][2*i1]
+0.5 * z1[i1];
u[2*i3][2*i2+1][2*i1+1] = u[2*i3][2*i2+1][2*i1+1]
+0.25*( z1[i1] + z1[i1+1] );
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3+1][2*i2][2*i1] = u[2*i3+1][2*i2][2*i1]
+0.5 * z2[i1];
u[2*i3+1][2*i2][2*i1+1] = u[2*i3+1][2*i2][2*i1+1]
+0.25*( z2[i1] + z2[i1+1] );
}
for (i1 = 0; i1 < mm1-1; i1++) {
u[2*i3+1][2*i2+1][2*i1] = u[2*i3+1][2*i2+1][2*i1]
+0.25* z3[i1];
u[2*i3+1][2*i2+1][2*i1+1] = u[2*i3+1][2*i2+1][2*i1+1]
+0.125*( z3[i1] + z3[i1+1] );
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(i1,i2,i3,z1,z2,z3)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for default(shared) private(i1,i2,i3,a) reduction(+:s) reduction(max:tmp)
| 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++) {
for (i2 = 1; i2 < n2-1; i2++) {
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 default(shared) private(i1,i2,i3,a) reduction(+:s) reduction(max:tmp)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/NPB3.0-omp-c/MG/mg.c
|
#pragma omp parallel for private(i2, i1)
| 100
|
ber\n");
for (i = MM-1; i >= 0; i--) {
printf(" %4d", jg[0][i][1]);
}
printf("\n");*/
<LOOP-START>for (i3 = 0; i3 < n3; i3++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i2, i1) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/original/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++) {
for (i2 = 0; i2 < n2; i2++) {
for (i1 = 0; i1 < n1; i1++) {
z[i3][i2][i1] = 0.0;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i1,i2,i3)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB049-fprintf-orig-no.c
|
#pragma omp parallel for simd
| 100
|
ain(int argc, char* argv[])
{
int i;
int ret;
FILE* pfile;
int len=1000;
int A[1000];
<LOOP-START>for (i=0; i<len; i++)
A[i]=i;
pfile = fopen("mytempfile.txt","a+");
if (pfile ==NULL)
{
fprintf(stderr,"Error in fopen()\n");
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB049-fprintf-orig-no.c
|
#pragma omp parallel for simd ordered
| 100
|
en("mytempfile.txt","a+");
if (pfile ==NULL)
{
fprintf(stderr,"Error in fopen()\n");
}
<LOOP-START>for (i=0; i<len; ++i)
{
#pragma omp ordered simd
fprintf(pfile, "%d\n", A[i] );
}<LOOP-END> <OMP-START>#pragma omp parallel for simd ordered<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB020-privatemissing-var-yes.c
|
#pragma omp parallel for simd
| 100
|
rgv[])
{
int i;
int tmp;
int len=100;
if (argc>1)
len = atoi(argv[1]);
int a[len];
<LOOP-START>for (i=0;i<len;i++)
a[i]=i;
#pragma omp parallel for simd private(tmp)
for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB020-privatemissing-var-yes.c
|
#pragma omp parallel for simd private(tmp)
| 100
|
atoi(argv[1]);
int a[len];
#pragma omp parallel for simd
for (i=0;i<len;i++)
a[i]=i;
<LOOP-START>for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd private(tmp)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB050-functionparameter-orig-yes.c
|
#pragma omp parallel for simd
| 100
|
i] = volnew_o8;
}
}
int main()
{
double o1[101];
double c[101];
int i;
int len = 100;
<LOOP-START>for (i = 0; i < len; ++i) {
c[i] = i + 1.01;
o1[i] = i + 1.01;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB050-functionparameter-orig-no.c
|
#pragma omp parallel for simd
| 100
|
Arrays passed as function parameters
*/
void foo1(double o1[], double c[], int len)
{
int i ;
<LOOP-START>for (i = 0; i < len; ++i) {
double volnew_o8 = 0.5 * c[i];
o1[i] = volnew_o8;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB050-functionparameter-orig-no.c
|
#pragma omp parallel for simd
| 100
|
o1[i] = volnew_o8;
}
}
double o1[100];
double c[100];
int main()
{
int i;
int len = 100;
<LOOP-START>for (i = 0; i < len; ++i) {
c[i] = i + 1.01;
o1[i] = i + 1.01;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB028-privatemissing-orig-yes.c
|
#pragma omp parallel for simd
| 100
|
ude <stdio.h>
int main(int argc, char* argv[])
{
int i;
int tmp;
int len=100;
int a[100];
<LOOP-START>for (i=0;i<len;i++)
a[i]=i;
#pragma omp parallel for simd private(tmp)
for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB028-privatemissing-orig-yes.c
|
#pragma omp parallel for simd private(tmp)
| 100
|
;
int len=100;
int a[100];
#pragma omp parallel for simd
for (i=0;i<len;i++)
a[i]=i;
<LOOP-START>for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd private(tmp)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB048-firstprivate-orig-no.c
|
#pragma omp parallel for simd firstprivate (g)
| 100
|
nclude <stdlib.h>
/*
Example use of firstprivate()
*/
void foo(int * a, int n, int g)
{
int i;
<LOOP-START>for (i=0;i<n;i++)
{
a[i] = a[i]+g;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd firstprivate (g)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB048-firstprivate-orig-no.c
|
#pragma omp parallel for simd
| 100
|
for (i=0;i<n;i++)
{
a[i] = a[i]+g;
}
}
int a[100];
int main()
{
int i;
int n = 100;
<LOOP-START>for (i=0;i<n;i++)
{
a[i] = i;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB048-firstprivate-orig-no.c
|
#pragma omp parallel for simd ordered
| 100
|
00;
#pragma omp parallel for simd
for (i=0;i<n;i++)
{
a[i] = i;
}
foo(a, 100, 7);
<LOOP-START>for (i=0;i<n;i++)
{
#pragma omp ordered simd
printf("%d\n",a[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for simd ordered<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB003-antidep2-orig-yes.c
|
#pragma omp parallel for private(j)
| 100
|
e <stdlib.h>
int main(int argc,char *argv[])
{
int i, j;
int len = 20;
double a[20][20];
<LOOP-START>for (i=0; i< len; i++)
#pragma omp parallel for simd
for (j=0; j<len; j++)
a[i][j] = (i * len + j + 0.5);
for (i = 0; i < len - 1; i += 1) {
#pragma omp parallel for simd
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB003-antidep2-orig-yes.c
|
#pragma omp parallel for simd
| 100
|
len = 20;
double a[20][20];
#pragma omp parallel for private(j)
for (i=0; i< len; i++)
<LOOP-START>for (j=0; j<len; j++)
a[i][j] = (i * len + j + 0.5);
for (i = 0; i < len - 1; i += 1) {
#pragma omp parallel for simd
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for simd <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB003-antidep2-orig-yes.c
|
#pragma omp parallel for simd
| 100
|
r (j=0; j<len; j++)
a[i][j] = (i * len + j + 0.5);
for (i = 0; i < len - 1; i += 1) {
<LOOP-START>for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB005-indirectaccess1-orig-yes.c
|
#pragma omp parallel for simd
| 100
|
* xa1 = base;
double * xa2 = xa1 + 2014;
int i;
// initialize segments touched by indexSet
<LOOP-START>for (i =521; i<= 2025; ++i)
{
base[i]=0.5*i;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB005-indirectaccess1-orig-yes.c
|
#pragma omp parallel for simd schedule(static,1)
| 100
|
]=0.5*i;
}
// default static even scheduling may not trigger data race, using static,1 instead.
<LOOP-START>for (i =0; i< N; ++i)
{
int idx = indexSet[i];
xa1[idx]+= 1.0 + i;
xa2[idx]+= 3.0 + i;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd schedule(static,1)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB004-antidep2-var-yes.c
|
#pragma omp parallel for private(j)
| 100
|
])
{
int i, j;
int len = 20;
if (argc>1)
len = atoi(argv[1]);
double a[len][len];
<LOOP-START>for (i=0; i< len; i++)
#pragma omp parallel for simd
for (j=0; j<len; j++)
a[i][j] = 0.5;
for (i = 0; i < len - 1; i += 1) {
#pragma omp parallel for simd
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB004-antidep2-var-yes.c
|
#pragma omp parallel for simd
| 100
|
rgv[1]);
double a[len][len];
#pragma omp parallel for private(j)
for (i=0; i< len; i++)
<LOOP-START>for (j=0; j<len; j++)
a[i][j] = 0.5;
for (i = 0; i < len - 1; i += 1) {
#pragma omp parallel for simd
for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/LLNL/AutoParBench/benchmarks/reference_cpu_simd/dataracebench/DRB004-antidep2-var-yes.c
|
#pragma omp parallel for simd
| 100
|
for simd
for (j=0; j<len; j++)
a[i][j] = 0.5;
for (i = 0; i < len - 1; i += 1) {
<LOOP-START>for (j = 0; j < len ; j += 1) {
a[i][j] += a[i + 1][j];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/RRZE-HPC/MD-Bench/src/clusterpair/force_eam.c
|
#pragma omp parallel for
| 100
|
eam->nrho_tot;
*/
double S = getTimeStamp();
LIKWID_MARKER_START("force");
/*
<LOOP-START>for(int i = 0; i < Nlocal; i++) {
neighs = &neighbor->neighbors[i * neighbor->maxneighs];
int numneighs = neighbor->numneigh[i];
MD_FLOAT xtmp = atom_x(i);
MD_FLOAT ytmp = atom_y(i);
MD_FLOAT ztmp = atom_z(i);
MD_FLOAT rhoi = 0;
#ifdef EXPLICIT_TYPES
const int type_i = atom->type[i];
#pragma ivdep
for(int k = 0; k < numneighs; k++) {
int j = neighs[k];
MD_FLOAT delx = xtmp - atom_x(j);
MD_FLOAT dely = ytmp - atom_y(j);
MD_FLOAT delz = ztmp - atom_z(j);
MD_FLOAT rsq = delx * delx + dely * dely + delz * delz;
#ifdef EXPLICIT_TYPES
const int type_j = atom->type[j];
const int type_ij = type_i * ntypes + type_j;
const MD_FLOAT cutforcesq = atom->cutforcesq[type_ij];
#else
const MD_FLOAT cutforcesq = param->cutforce * param->cutforce;
if(rsq < cutforcesq) {
MD_FLOAT p = sqrt(rsq) * rdr + 1.0;
int m = (int)(p);
m = m < nr - 1 ? m : nr - 1;
p -= m;
p = p < 1.0 ? p : 1.0;
#ifdef EXPLICIT_TYPES
rhoi += ((rhor_spline[type_ij * nr_tot + m * 7 + 3] * p +
rhor_spline[type_ij * nr_tot + m * 7 + 4]) * p +
rhor_spline[type_ij * nr_tot + m * 7 + 5]) * p +
rhor_spline[type_ij * nr_tot + m * 7 + 6];
#else
rhoi += ((rhor_spline[m * 7 + 3] * p +
rhor_spline[m * 7 + 4]) * p +
rhor_spline[m * 7 + 5]) * p +
rhor_spline[m * 7 + 6];
}
}
#ifdef EXPLICIT_TYPES
const int type_ii = type_i * type_i;
MD_FLOAT p = 1.0 * rhoi * rdrho + 1.0;
int m = (int)(p);
m = MAX(1, MIN(m, nrho - 1));
p -= m;
p = MIN(p, 1.0);
#ifdef EXPLICIT_TYPES
fp[i] = (frho_spline[type_ii * nrho_tot + m * 7 + 0] * p +
frho_spline[type_ii * nrho_tot + m * 7 + 1]) * p +
frho_spline[type_ii * nrho_tot + m * 7 + 2];
#else
fp[i] = (frho_spline[m * 7 + 0] * p + frho_spline[m * 7 + 1]) * p + frho_spline[m
* 7 + 2];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/imsure/parallel-programming/matrix-multiplication/matrix-mul-openmp.c
|
#pragma omp parallel for shared(matrix1, matrix2, matrix3, chunksize) \
| 100
|
rintf( "Matrix 2:\n" );
print_matrix( matrix2, size );
}
gettimeofday( &tstart, NULL );
<LOOP-START>private(i,j,k,sum) schedule(static, chunksize)
for (i = 0; i < size; ++i) { // hold row index of 'matrix1'
for (j = 0; j < size; ++j) { // hold column index of 'matrix2'
sum = 0; // hold value of a cell
/* one pass to sum the multiplications of corresponding cells
in the row vector and column vector. */
for (k = 0; k < size; ++k) {
sum += matrix1[ i ][ k ] * matrix2[ k ][ j ];
}
matrix3[ i ][ j ] = sum;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(matrix1, matrix2, matrix3, chunksize) \<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/imsure/parallel-programming/red-black-grid-computation/rb-grid-hybrid.c
|
#pragma omp parallel for shared(grid,num_threads) private(i,j,jstart) schedule (static, chunk_size)
| 100
|
compute_grid_red( double **grid, int gridsize, int strip_size, int myrank )
{
int i, j, jstart;
<LOOP-START>for (i = 1; i < strip_size-1; i++) {
if (i % 2 == 1) jstart = 1; // odd row
else jstart = 2; // even row
for (j = jstart; j < gridsize-1; j += 2) {
grid[ i ][ j ] = ( grid[ i-1 ][ j ] + grid[ i+1 ][ j ] +
grid[ i ][ j-1 ] + grid[ i ][ j+1 ] ) * 0.25;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(grid,num_threads) private(i,j,jstart) schedule (static, chunk_size)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/imsure/parallel-programming/red-black-grid-computation/rb-grid-hybrid.c
|
#pragma omp parallel for shared(grid,num_threads) private(i,j,jstart) schedule (static, chunk_size)
| 100
|
ompute_grid_black( double **grid, int gridsize, int strip_size, int myrank )
{
int i, j, jstart;
<LOOP-START>for (i = 1; i < strip_size-1; i++) {
if (i % 2 == 1) jstart = 2; // odd row
else jstart = 1; // even row
for (j = jstart; j < gridsize-1; j += 2) {
grid[ i ][ j ] = ( grid[ i-1 ][ j ] + grid[ i+1 ][ j ] +
grid[ i ][ j-1 ] + grid[ i ][ j+1 ] ) * 0.25;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(grid,num_threads) private(i,j,jstart) schedule (static, chunk_size)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/2. K-means with OpenMP/kmeans2/kmeans2.c
|
#pragma omp parallel for reduction(+:tot_dist)
| 100
|
n");
}
}
//returns the total minimum distance
float estimate_class(void) {
float tot_dist = 0.0;
<LOOP-START>for(int i=0;i<N;i++){
float min_dist = distance(Vec[i], Center[0]); //distance from first center = initial min
int class_num = 0; //corresponding classification is 0
float dist;
for(int j=1;j<NC;j++){
dist = distance(Vec[i], Center[j]);
if(dist < min_dist){
min_dist = dist; //update min distance
class_num = j; //update classification
}
}
tot_dist += min_dist; //add final min_dist
Class[i] = class_num; //update Class array with the final ith vector classification
//printf("%d ", Class[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_dist) <OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/2. K-means with OpenMP/kmeans3/kmeans3.c
|
#pragma omp parallel for reduction(+:tot_dist) schedule(static,50)
| 100
|
n");
}
}
//returns the total minimum distance
float estimate_class(void) {
float tot_dist = 0.0;
<LOOP-START>//#pragma omp simd
for(int i=0;i<N;i++){
float min_dist = distance(Vec[i], Center[0]); //distance from first center = initial min
int class_num = 0; //corresponding classification is 0
float dist;
for(int j=1;j<NC;j++){
dist = distance(Vec[i], Center[j]);
if(dist < min_dist){
min_dist = dist; //update min distance
class_num = j; //update classification
}
}
tot_dist += min_dist; //add final min_dist
Class[i] = class_num; //update Class array with the final ith vector classification
//printf("%d ", Class[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_dist) schedule(static,50)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/2. K-means with OpenMP/kmeans4/kmeans4.c
|
#pragma omp parallel for reduction(+:tot_dist) schedule(static,50)
| 100
|
n");
}
}
//returns the total minimum distance
float estimate_class(void) {
float tot_dist = 0.0;
<LOOP-START>for(int i=0;i<N;i++){
float min_dist = distance(Vec[i], Center[0]); //distance from first center = initial min
int class_num = 0; //corresponding classification is 0
float dist;
for(int j=1;j<NC;j++){
dist = distance(Vec[i], Center[j]);
if(dist < min_dist){
min_dist = dist; //update min distance
class_num = j; //update classification
}
}
tot_dist += min_dist; //add final min_dist
Class[i] = class_num; //update Class array with the final ith vector classification
//printf("%d ", Class[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_dist) schedule(static,50)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.0.c
|
#pragma omp parallel for reduction(my_min:nearest_city) private(dist)
| 100
|
ity.dist = 1e6;
nearest_city.city = -1;
printf("\n\nVISIT CLOSEST FROM: %d\n\n", to_visit-1);
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
printf("Distance between %d and %d: %f\n",i, Sequence[to_visit-1], dist);
if(dist < nearest_city.dist){
nearest_city.dist = dist;
nearest_city.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.3.c
|
#pragma omp parallel for reduction(my_min:nearest_city) private(dist)
| 100
|
initialize nearest_city
nearest nearest_city;
nearest_city.dist = 1e6;
nearest_city.city = -1;
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
if(dist < nearest_city.dist){
nearest_city.dist = dist;
nearest_city.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.3.c
|
#pragma omp parallel for reduction(my_min:nearest_city1) private(dist)
| 100
|
_city1.dist = 1e6;
nearest_city1.city = -1;
nearest_city2.dist = 1e6;
nearest_city2.city = -1;
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
if(dist < nearest_city1.dist){
nearest_city1.dist = dist;
nearest_city1.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city1) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.3.c
|
#pragma omp parallel for reduction(my_min:nearest_city2) private(dist)
| 100
|
ed[nearest_city1.city] = true;
return nearest_city1.dist;
}else{
//find second nearest city
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i] && i != nearest_city1.city){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
if(dist < nearest_city2.dist){
nearest_city2.dist = dist;
nearest_city2.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city2) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.2.c
|
#pragma omp parallel for reduction(my_min:nearest_city) private(dist)
| 100
|
initialize nearest_city
nearest nearest_city;
nearest_city.dist = 1e6;
nearest_city.city = -1;
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
if(dist < nearest_city.dist){
nearest_city.dist = dist;
nearest_city.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.1.c
|
#pragma omp parallel for reduction(my_min:nearest_city) private(dist)
| 100
|
ity.dist = 1e6;
nearest_city.city = -1;
printf("\n\nVISIT CLOSEST FROM: %d\n\n", to_visit-1);
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
printf("Distance between %d and %d: %f\n",i, Sequence[to_visit-1], dist);
if(dist < nearest_city.dist){
nearest_city.dist = dist;
nearest_city.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.1.c
|
#pragma omp parallel for reduction(my_min:nearest_city1) private(dist)
| 100
|
t = 1e6;
nearest_city2.city = -1;
printf("\n\nVISIT SECOND CLOSEST FROM: %d\n\n", to_visit-1);
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i]){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
printf("Distance between %d and %d: %f\n",i, Sequence[to_visit-1], dist);
if(dist < nearest_city1.dist){
nearest_city1.dist = dist;
nearest_city1.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city1) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman5/travelling_salesman5.1.c
|
#pragma omp parallel for reduction(my_min:nearest_city2) private(dist)
| 100
|
ed[nearest_city1.city] = true;
return nearest_city1.dist;
}else{
//find second nearest city
<LOOP-START>for(int i=1;i<NUM_CITIES;i++){
if(!Visited[i] && i != nearest_city1.city){
dist = distance(i, Sequence[to_visit-1]); //distance from last city on the sequence so far
if(dist < nearest_city2.dist){
nearest_city2.dist = dist;
nearest_city2.city = i;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(my_min:nearest_city2) private(dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.1.c
|
#pragma omp parallel for schedule(static,2)
| 100
|
;
swapped_indices[1] = ind2;
}
void calc_adjacent_dists(int *swapped_indices, float *adj_dists){
<LOOP-START>for(int i=0;i<2;i++){
*adj_dists++ = distance(swapped_indices[i], swapped_indices[i]-1);
*adj_dists++ = distance(swapped_indices[i], swapped_indices[i]+1);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static,2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.1.c
|
#pragma omp parallel for simd reduction(+:old_tot_dist) schedule(static,4)
| 100
|
from the difference of only the 4 affected distances
//instead of recalculating every distance
<LOOP-START>for(int i=0;i<4;i++){
old_tot_dist += new_dists[i] - prev_dists[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd reduction(+:old_tot_dist) schedule(static,4)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.1.c
|
#pragma omp parallel for reduction(+:tot_dist)
| 100
|
- prev_dists[i];
}
return old_tot_dist;
}
float total_distance(void){
float tot_dist = 0.0;
<LOOP-START>for (int i=0;i<NUM_CITIES;i++){
tot_dist += distance(i, i+1);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.0.c
|
#pragma omp parallel for schedule(static,2)
| 100
|
swapped_indices[1] = ind2;
}
void calc_adjacent_dists(int *swapped_indices, float *adj_dists){
//<LOOP-START>for(int i=0;i<2;i++){
*adj_dists++ = distance(swapped_indices[i], swapped_indices[i]-1);
*adj_dists++ = distance(swapped_indices[i], swapped_indices[i]+1);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static,2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.0.c
|
#pragma omp parallel for simd reduction(+:old_tot_dist) schedule(static,4)
| 100
|
rom the difference of only the 4 affected distances
//instead of recalculating every distance
//<LOOP-START>for(int i=0;i<4;i++){
old_tot_dist += new_dists[i] - prev_dists[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd reduction(+:old_tot_dist) schedule(static,4)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/3. Travelling salesman problem/travelling_salesman2/travelling_salesman2.0.c
|
#pragma omp parallel for reduction(+:tot_dist)
| 100
|
- prev_dists[i];
}
return old_tot_dist;
}
float total_distance(void){
float tot_dist = 0.0;
<LOOP-START>for (int i=0;i<NUM_CITIES;i++){
tot_dist += distance(i, i+1);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_dist)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens2/Queens2.0.c
|
#pragma omp parallel for
| 100
|
-; //backtrack to previous column
}
}
print_results(tries);
return 0;
}
void board_init(){
<LOOP-START>for(int i=0;i<N;i++){
ROWS_PLACED[i] = -1; //no queens are placed
VALID_ROWS[0][i] = true; //all rows of the first column are valid
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens2/Queens2.0.c
|
#pragma omp parallel for
| 100
|
irst column are valid
}
}
//calculates valid rows of next column
void calc_next_valid(int col){
<LOOP-START>for(int row=0;row<N;row++){
VALID_ROWS[col][row] = isvalid(row, col);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens2/Queens2.1.c
|
#pragma omp parallel for simd
| 100
|
en & backtrack to previous column
}
}
print_results(tries);
return 0;
}
void board_init(){
<LOOP-START>for(int i=0;i<N;i++){
ROWS_PLACED[i] = -1; //no queens are placed
for(int j=0;j<N;j++){
VALID_ROWS[i][j] = true; //all positions are valid
}
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens2/Queens2.1.c
|
#pragma omp parallel for
| 100
|
positions are valid
}
}
}
//calculates valid rows of current column
void calc_valid(int col){
<LOOP-START>for(int row=0;row<N;row++){
VALID_ROWS[col][row] = isvalid(row, col);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.1.c
|
#pragma omp parallel for private(gene1, gene2)
| 100
|
TION_SIZE-1] = 1.0;
while(1){
found = fitness();
if(found >= 0) break;
generation++;
<LOOP-START>for(int pair=0;pair<POPULATION_SIZE/2;pair++){
gene1 = select_gene();
gene2 = select_gene();
if(gene1 != gene2){
#pragma omp critical
crossover(NEW_POPULATION[gene1], NEW_POPULATION[gene2]);
}
#pragma omp critical
{
mutation(NEW_POPULATION[gene1]);
mutation(NEW_POPULATION[gene2]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(gene1, gene2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.1.c
|
#pragma omp parallel for private(random_row)
| 100
|
ray is used --> max(N) = 256 = max(queens)
void population_init(void){
unsigned char random_row;
<LOOP-START>for(int i=0;i<POPULATION_SIZE;i++){ //each gene
for(int j=0;j<N;j++){ //each column
random_row = (unsigned char)rand()%N; //random row
POPULATION[i][j] = random_row;
NEW_POPULATION[i][j] = random_row;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(random_row)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.1.c
|
#pragma omp parallel for
| 100
|
pulation after crossover and mutation
void update_population(void){
//population = new population
<LOOP-START>for(int i=0;i<POPULATION_SIZE;i++){
#pragma omp simd
for(int j=0;j<N;j++){
POPULATION[i][j] = NEW_POPULATION[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.0.c
|
#pragma omp parallel for private(gene1, gene2)
| 100
|
TION_SIZE-1] = 1.0;
while(1){
found = fitness();
if(found >= 0) break;
generation++;
<LOOP-START>for(int pair=0;pair<POPULATION_SIZE/2;pair++){
gene1 = select_gene();
gene2 = select_gene();
if(gene1 != gene2){
#pragma omp critical
crossover(NEW_POPULATION[gene1], NEW_POPULATION[gene2]);
}
#pragma omp critical
{
mutation(NEW_POPULATION[gene1]);
mutation(NEW_POPULATION[gene2]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(gene1, gene2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.0.c
|
#pragma omp parallel for private(random_row)
| 100
|
ray is used --> max(N) = 256 = max(queens)
void population_init(void){
unsigned char random_row;
<LOOP-START>for(int i=0;i<POPULATION_SIZE;i++){ //each gene
for(int j=0;j<N;j++){ //each column
random_row = (unsigned char)rand()%N; //random row
POPULATION[i][j] = random_row;
NEW_POPULATION[i][j] = random_row;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(random_row)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/5. N queens problem/Queens4/Queens4.0.c
|
#pragma omp parallel for
| 100
|
pulation after crossover and mutation
void update_population(void){
//population = new population
<LOOP-START>for(int i=0;i<POPULATION_SIZE;i++){
#pragma omp simd
for(int j=0;j<N;j++){
POPULATION[i][j] = NEW_POPULATION[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/4. Neural networks/NN4/NN4.2.c
|
#pragma omp parallel for private(y)
| 100
|
n temp/((1+temp)*(1+temp));
}
void activate_NN(double *vector_in) {
double y;
//internal layer
<LOOP-START>for(int i=0;i<L1_NEURONS;i++){
//w0 corresponds to extra constant input 1
y = WL1[i][0]; //no point in multiplying by 1
#pragma omp simd
for(int j=1;j<L1_DIM;j++){
y += vector_in[j-1] * WL1[i][j];
}
//store neuron y and output
DL1[i] = y;
OL1[i] = sigmoid(y);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/4. Neural networks/NN4/NN4.2.c
|
#pragma omp parallel for private(acc)
| 100
|
d_derivative(DL2[i]) * (desired[i] - OL2[i]); //equation III
}
//internal neurons
double acc;
<LOOP-START>for(int i=0;i<L1_NEURONS;i++){
acc = 0.0;
#pragma omp simd
for(int k=0;k<L2_NEURONS;k++){
acc += DELTA_L2[k] * temp[i+1][k];
}
DELTA_L1[i] = sigmoid_derivative(DL1[i]) * acc; //equation II
}<LOOP-END> <OMP-START>#pragma omp parallel for private(acc)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/4. Neural networks/NN4/NN4.2.c
|
#pragma omp parallel for private(delta_i)
| 100
|
; //equation II
}
}
void update_weights(double *vector_in){
double delta_i;
//layer 1 weights
<LOOP-START>for(int i=0;i<L1_NEURONS;i++){
delta_i = DELTA_L1[i];
WL1[i][0] += ALPHA * delta_i;
#pragma omp simd
for(int j=1;j<L1_DIM;j++){
WL1[i][j] += ALPHA * delta_i * vector_in[j-1]; //equation I
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(delta_i)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/n-roussos/Parallel-Programming-with-OpenMP/4. Neural networks/NN4/NN4.2.c
|
#pragma omp parallel for private(max,predicted_class, OL1, OL2)
| 100
|
hts(vector_in);
}
double train_accuracy(void){
double max;
int predicted_class, correct = 0;
//<LOOP-START>for(int i=0;i<TRAIN_EXAMPLES;i++){
activate_NN(TRAIN_DATA[i]); //predict
max = OL2[0];
predicted_class = 0;
for(int j=1;j<L2_NEURONS;j++){
if(OL2[j] > max){
max = OL2[j];
predicted_class = j;
}
}
if(predicted_class == TRAIN_CLASS[i]){
//#pragma omp atomic update
correct++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(max,predicted_class, OL1, OL2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/rahulsonone1234/Parallel-Programming/ContrastStretchingImageParallel.c
|
#pragma omp parallel for
| 100
|
png_destroy_write_struct(&png, &info);
}
int main()
{
double startTime = omp_get_wtime();
<LOOP-START>for(int i=1;i<=800;i++)
{
char str[25]="cat (";
char out[25]="out (";
int a=i;
int tmp=i;
int cnt=0;
while(tmp)
{
tmp=tmp/10;
cnt++;
}
int j=cnt-1;
char pok[25]=").png";
char lok[25];
while(a)
{
int k=a%10;
lok[j]=(char)('0'+k);
a=a/10;
j--;
}
lok[cnt]='\0';
strcat(str,lok);
strcat(str,pok);
strcat(out,lok);
strcat(out,pok);
char* s=out;
char* p=str;
read_png_file(p,s);
//fflush(stdin);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/rahulsonone1234/Parallel-Programming/LoGParallel.c
|
#pragma omp parallel for
| 100
|
ng_destroy_write_struct(&png, &info);
}
int main() {
double startTime = omp_get_wtime();
<LOOP-START>for(int i=1;i<=4;i++)
{
char str[25]="cat (";
char out[25]="out (";
int a=i;
int tmp=i;
int cnt=0;
while(tmp)
{
tmp=tmp/10;
cnt++;
}
int j=cnt-1;
char pok[25]=").png";
char lok[25];
while(a)
{
int k=a%10;
lok[j]=(char)('0'+k);
a=a/10;
j--;
}
lok[cnt]='\0';
strcat(str,lok);
strcat(str,pok);
strcat(out,lok);
strcat(out,pok);
char* s=out;
char* p=str;
edgeDetection(p,s);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/rahulsonone1234/Parallel-Programming/EdgeDetectionfinalparallel.c
|
#pragma omp parallel for
| 100
|
ng_destroy_write_struct(&png, &info);
}
int main() {
double startTime = omp_get_wtime();
<LOOP-START>for(int i=1;i<=800;i++)
{
char str[25]="cat (";
char out[25]="out (";
int a=i;
int tmp=i;
int cnt=0;
while(tmp)
{
tmp=tmp/10;
cnt++;
}
int j=cnt-1;
char pok[25]=").png";
char lok[25];
while(a)
{
int k=a%10;
lok[j]=(char)('0'+k);
a=a/10;
j--;
}
lok[cnt]='\0';
strcat(str,lok);
strcat(str,pok);
strcat(out,lok);
strcat(out,pok);
char* s=out;
char* p=str;
edgeDetection(p,s);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/rahulsonone1234/Parallel-Programming/negationImageParallel.c
|
#pragma omp parallel for
| 100
|
png_destroy_write_struct(&png, &info);
}
int main()
{
double startTime = omp_get_wtime();
<LOOP-START>for(int i=1;i<=4;i++)
{
char str[25]="cat (";
char out[25]="out (";
int a=i;
int tmp=i;
int cnt=0;
while(tmp)
{
tmp=tmp/10;
cnt++;
}
int j=cnt-1;
char pok[25]=").png";
char lok[25];
while(a)
{
int k=a%10;
lok[j]=(char)('0'+k);
a=a/10;
j--;
}
lok[cnt]='\0';
strcat(str,lok);
strcat(str,pok);
strcat(out,lok);
strcat(out,pok);
char* s=out;
char* p=str;
read_png_file(p,s);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/mghojal/Edge-detection-using-laplacian-operator/header.h
|
#pragma omp parallel for collapse(2)
| 100
|
int x,y;
// for each row, column, calculating the new value using Stencil Matrix (laplacian)
<LOOP-START>for ( y = 1; y < in->height-2; y++ ) {
for( x = 1; x < in->width-2; x++ ) {
double val = abs(
8 * image_get_pixeld(in, x, y) -(
image_get_pixeld(in, x-1, y-1 ) +
image_get_pixeld(in, x , y-1 ) +
image_get_pixeld(in, x+1, y-1 ) +
image_get_pixeld(in, x-1, y ) +
image_get_pixeld(in, x+1, y ) +
image_get_pixeld(in, x-1, y+1 ) +
image_get_pixeld(in, x , y+1 ) +
image_get_pixeld(in, x+1, y+1 )));
buffer[y*in->width+x] = val;
//#pragma omp critical
{
if ( val > max ) max = val;
if ( val < min ) min = val;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/mghojal/Edge-detection-using-laplacian-operator/header.h
|
#pragma omp parallel for collapse(2)
| 100
|
n ) min = val;
}
}
}
//Normailzing the values and set pixel value in the proper location
<LOOP-START>for ( y = 0; y < in->height; y++ ) {
for( x = 0; x < in->width; x++ ) {
double val = MAX_BRIGHTNESS * (buffer[y*in->width+x] - min) / (max-min);
image_set_pixel( out, x, y, val );
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/mghojal/Edge-detection-using-laplacian-operator/header.h
|
#pragma omp parallel for collapse(2)
| 100
|
fo_ptr);
width = png_get_image_width(png_ptr, info_ptr);
image = image_create( width, height );
<LOOP-START>for ( y = 0; y < height; y++ ) {
for( x = 0; x < width; x++ ) {
unsigned c = 0;
unsigned char* ch = (unsigned char*)&c;
unsigned char* array = row_pointers[y];
ch[0] = array[x];
image_set_pixel(image, x, y, c);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/nathanlo99/nart/src/raytracer.cpp
|
#pragma omp parallel for schedule(guided) collapse(2)
| 100
|
_pixels = screen_height * screen_width;
size_t num_processed = 0;
auto last_ms = milli_time();
<LOOP-START>for (size_t y = 0; y < screen_height; y++) {
for (size_t x = 0; x < screen_width; x++) {
vec3 result_colour = vec3();
for (size_t i = 0; i < aa_num * aa_num; i++) {
const float rx = (i / aa_num) / aa_num, ry = (i % aa_num) / aa_num;
const vec3 dir = forward //
+ (x - (screen_width / 2.0f) + rx) * dx //
+ (y - (screen_height / 2.0f) + ry) * dy;
const Ray ray{camera_position, glm::normalize(dir)};
const vec3 c = scene.intersect(ray, max_depth);
result_colour += c;
}
result.set(x, y, result_colour / (float)(aa_num * aa_num));
#pragma omp critical
{
num_processed++;
const auto cur_ms = milli_time();
if (cur_ms - last_ms > 1000) {
last_ms = cur_ms;
const float percent = num_processed * 100. / num_pixels;
INFO("Completed " + std::to_string(percent) + "% of " + render_name);
result.write(ImageFormat::BMP, "tmp/progress.bmp");
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided) collapse(2)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/oldExamples/appFor_vSched-omp.C
|
#pragma omp parallel for
| 100
|
)malloc(sizeof(float)*probSize);
// initialize input vectors, use standard worksharing here.
<LOOP-START>for (int i = 0 ; i < probSize ; i++)
{
a[i] = i*1.0;
b[i] = 1.0;
#ifdef VERBOSE
int myTid = omp_get_thread_num();
printf("tid in init = %d", myTid);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/oldExamples/app2For_vSched-omp.C
|
#pragma omp parallel for
| 100
|
)malloc(sizeof(float)*probSize);
// initialize input vectors, use standard worksharing here.
<LOOP-START>for (int i = 0 ; i < probSize ; i++)
{
a[i] = i*1.0;
b[i] = 1.0;
#ifdef VERBOSE
int myTid = omp_get_thread_num();
printf("tid in init = %d", myTid);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/oldExamples/appFor-OpenMP-vSched.C
|
#pragma omp parallel for
| 100
|
)malloc(sizeof(float)*probSize);
// initialize input vectors, use standard worksharing here.
<LOOP-START>for (int i = 0 ; i < probSize ; i++)
{
a[i] = i*1.0;
b[i] = 1.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/examples/appFor_omp-lols.C
|
#pragma omp parallel for
| 100
|
)malloc(sizeof(float)*probSize);
// initialize input vectors, use standard worksharing here.
<LOOP-START>for (int i = 0 ; i < probSize ; i++)
{
a[i] = i*1.0;
b[i] = 1.0;
#ifdef VERBOSE
int myTid = omp_get_thread_num();
printf("tid in init = %d", myTid);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/tests/perf/testOneFor_omp-lols.C
|
#pragma omp parallel for
| 100
|
)malloc(sizeof(float)*probSize);
// initialize input vectors, use standard worksharing here.
<LOOP-START>for (int i = 0 ; i < probSize ; i++)
{
a[i] = i*1.0;
b[i] = 1.0;
#ifdef VERBOSE
int myTid = omp_get_thread_num();
printf("tid in init = %d", myTid);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/share/ukernels/mandelbrot-hybrid.cpp
|
#pragma omp parallel for private(i, j)
| 100
|
me start of %d\n",iproc,myRecvArr[0]);
myJobStart = myRecvArr[0];
// do work
<LOOP-START>for (j = 0; j < BLOCK_HEIGHT; j++) {
for (i = 0; i < BLOCK_WIDTH; i++) {
pixels[i + j * BLOCK_WIDTH] = computePoint(i, j + myJobStart / 1536);
//fprintf(stderr,"%d ",pixels[i + j * BLOCK_WIDTH]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j)<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/share/ukernels/heat-mpi.cpp
|
#pragma omp parallel for
| 100
|
need ghost values of X but we'll throw them in
// as X[0] and X[N+1].
//
x = new double[n+2];
<LOOP-START>for ( i = 0; i <= n + 1; i++ )
{
x[i] = ( ( double ) ( id * n + i - 1 ) * x_max
+ ( double ) ( p * n - id * n - i ) * x_min )
/ ( double ) ( p * n - 1 );
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/share/ukernels/heat-mpi.cpp
|
#pragma omp parallel for
| 100
|
LD, &status );
#endif
}
//
// Update the temperature based on the four point stencil.
//
<LOOP-START>for ( i = 1; i <= n; i++ )
{
h_new[i] = h[i]
+ ( time_delta * k / x_delta / x_delta ) * ( h[i-1] - 2.0 * h[i] + h[i+1] )
+ time_delta * rhs ( x[i], time );
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END>
|
/ascldap/users/netienn/Research/HPC-Coder/data/ClonedRepos/vlkale/lw-sched/share/ukernels/matVec-mpi.c
|
#pragma omp parallel for
| 100
|
alloc ( n * sizeof ( double ) );
b = ( double * ) malloc ( m * sizeof ( double ) );
k = 0;
<LOOP-START>for ( i = 1; i <= m; i++ )
{
for ( j = 1; j <= n; j++ )
{
a[k] = sqrt ( 2.0 / ( double ) ( n + 1 ) )
* sin ( ( double ) ( i * j ) * pi / ( double ) ( n + 1 ) );
k = k + 1;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.