filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | i++)
y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows*num_vectors; i++)
y_data[i] = b_data[i]*temp;
}
}
else
{
for (i = 0; i < num_rows*num_vectors; i++)
y_data[i] = b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,m,tempx) HYPRE_SMP_SCHEDULE | 100 | ----------------------*/
if (num_rownnz < xpar*(num_rows))
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
/*
* for (jj = A_i[m]; jj < A_i[m+1]; jj++)
* {
* j = A_j[jj];
* y_data[m] += A_data[jj] * x_data[j];
* } */
if ( num_vectors==1 )
{
tempx = 0;
for (jj = A_i[m]; jj < A_i[m+1]; jj++)
tempx += A_data[jj] * x_data[A_j[jj]];
y_data[m] += tempx;
}
else
for ( j=0; j<num_vectors; ++j )
{
tempx = 0;
for (jj = A_i[m]; jj < A_i[m+1]; jj++)
tempx += A_data[jj] * x_data[ j*vecstride_x + A_j[jj]*idxstride_x ];
y_data[ j*vecstride_y + m*idxstride_y] += tempx;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,tempx) HYPRE_SMP_SCHEDULE | 100 | }
}
}
else // num_vectors > 1
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
for (j = 0; j < num_vectors; ++j)
{
tempx = 0;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[ j*vecstride_x + A_j[jj]*idxstride_x ];
}
y_data[ j*vecstride_y + i*idxstride_y ] += tempx;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | --------------------------------------*/
if (alpha != 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows*num_vectors; i++)
y_data[i] *= alpha;
}
}
else
{ // JSP: this is currently the only path optimized
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel private(i,jj,tempx)
{
HYPRE_Int iBegin = hypre_CSRMatrixGetLoadBalancedPartitionBegin(A);
HYPRE_Int iEnd = hypre_CSRMatrixGetLoadBalancedPartitionEnd(A);
hypre_assert(iBegin <= iEnd);
hypre_assert(iBegin >= 0 && iBegin <= num_rows);
hypre_assert(iEnd >= 0 && iEnd <= num_rows);
if (0 == temp)
{
if (1 == alpha) // JSP: a common path
{
for (i = iBegin; i < iEnd; i++)
{
tempx = 0.0;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = A*x
else if (-1 == alpha)
{
for (i = iBegin; i < iEnd; i++)
{
tempx = 0.0;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx -= A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = -A*x
else
{
for (i = iBegin; i < iEnd; i++)
{
tempx = 0.0;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = alpha*tempx;
}
} // y = alpha*A*x
} // temp == 0
else if (-1 == temp) // beta == -alpha
{
if (1 == alpha) // JSP: a common path
{
for (i = iBegin; i < iEnd; i++)
{
tempx = -b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = A*x - y
else if (-1 == alpha) // JSP: a common path
{
for (i = iBegin; i < iEnd; i++)
{
tempx = b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx -= A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = -A*x + y
else
{
for (i = iBegin; i < iEnd; i++)
{
tempx = -b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = alpha*tempx;
}
} // y = alpha*(A*x - y)
} // temp == -1
else if (1 == temp)
{
if (1 == alpha) // JSP: a common path
{
for (i = iBegin; i < iEnd; i++)
{
tempx = b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = A*x + y
else if (-1 == alpha)
{
for (i = iBegin; i < iEnd; i++)
{
tempx = -b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx -= A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = -A*x - y
else
{
for (i = iBegin; i < iEnd; i++)
{
tempx = b_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = alpha*tempx;
}
} // y = alpha*(A*x + y)
}
else
{
if (1 == alpha) // JSP: a common path
{
for (i = iBegin; i < iEnd; i++)
{
tempx = b_data[i]*temp;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = A*x + temp*y
else if (-1 == alpha)
{
for (i = iBegin; i < iEnd; i++)
{
tempx = -b_data[i]*temp;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx -= A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = tempx;
}
} // y = -A*x - temp*y
else
{
for (i = iBegin; i < iEnd; i++)
{
tempx = b_data[i]*temp;
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
tempx += A_data[jj] * x_data[A_j[jj]];
}
y_data[i] = alpha*tempx;
}
} // y = alpha*(A*x + temp*y)
} // temp != 0 && temp != -1 && temp != 1
} // omp parallel
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | --------------------------------------------*/
if (alpha == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols*num_vectors; i++)
y_data[i] *= beta;
return ierr;
}
if (x == y)
{
x_tmp = hypre_SeqVectorCloneDeep(x);
x_data = hypre_VectorData(x_tmp);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | beta / alpha;
if (temp != 1.0)
{
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols*num_vectors; i++)
y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_cols*num_vectors; i++)
y_data[i] *= temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | num_vectors; i++)
y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols*num_vectors; i++)
y_data[i] *= temp;
}
}
/*-----------------------------------------------------------------
* y += A^T*x
*-----------------------------------------------------------------*/
num_threads = hypre_NumThreads();
if (num_threads > 1)
{
y_data_expand = hypre_CTAlloc(HYPRE_Complex, num_threads*y_size);
if ( num_vectors==1 )
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel private(i,jj,j,my_thread_num,offset)
{
my_thread_num = hypre_GetThreadNum();
offset = y_size*my_thread_num;
#ifdef HYPRE_USING_OPENMP
#pragma omp for HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
{
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
j = A_j[jj];
y_data_expand[offset + j] += A_data[jj] * x_data[i];
}
}
/* implied barrier (for threads)*/
#ifdef HYPRE_USING_OPENMP
#pragma omp for HYPRE_SMP_SCHEDULE
for (i = 0; i < y_size; i++)
{
for (j = 0; j < num_threads; j++)
{
y_data[i] += y_data_expand[j*y_size + i];
}
}
} /* end parallel threaded region */
}
else
{
/* multiple vector case is not threaded */
for (i = 0; i < num_rows; i++)
{
for ( jv=0; jv<num_vectors; ++jv )
{
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
{
j = A_j[jj];
y_data[ j*idxstride_y + jv*vecstride_y ] +=
A_data[jj] * x_data[ i*idxstride_x + jv*vecstride_x];
}
}
}
}
hypre_TFree(y_data_expand);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | --------------------------------------------*/
if (alpha != 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols*num_vectors; i++)
y_data[i] *= alpha;
}
if (x == y) hypre_SeqVectorDestroy(x_tmp);
return ierr;
}
/*--------------------------------------------------------------------------
* hypre_CSRMatrixMatvec_FF
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_CSRMatrixMatvec_FF( HYPRE_Complex alpha,
hypre_CSRMatrix *A,
hypre_Vector *x,
HYPRE_Complex beta,
hypre_Vector *y,
HYPRE_Int *CF_marker_x,
HYPRE_Int *CF_marker_y,
HYPRE_Int fpt )
{
HYPRE_Complex *A_data = hypre_CSRMatrixData(A);
HYPRE_Int *A_i = hypre_CSRMatrixI(A);
HYPRE_Int *A_j = hypre_CSRMatrixJ(A);
HYPRE_Int num_rows = hypre_CSRMatrixNumRows(A);
HYPRE_Int num_cols = hypre_CSRMatrixNumCols(A);
HYPRE_Complex *x_data = hypre_VectorData(x);
HYPRE_Complex *y_data = hypre_VectorData(y);
HYPRE_Int x_size = hypre_VectorSize(x);
HYPRE_Int y_size = hypre_VectorSize(y);
HYPRE_Complex temp;
HYPRE_Int i, jj;
HYPRE_Int ierr = 0;
/*---------------------------------------------------------------------
* Check for size compatibility. Matvec returns ierr = 1 if
* length of X doesn't equal the number of columns of A,
* ierr = 2 if the length of Y doesn't equal the number of rows
* of A, and ierr = 3 if both are true.
*
* Because temporary vectors are often used in Matvec, none of
* these conditions terminates processing, and the ierr flag
* is informational only.
*--------------------------------------------------------------------*/
if (num_cols != x_size)
ierr = 1;
if (num_rows != y_size)
ierr = 2;
if (num_cols != x_size && num_rows != y_size)
ierr = 3;
/*-----------------------------------------------------------------------
* Do (alpha == 0.0) computation - RDF: USE MACHINE EPS
*-----------------------------------------------------------------------*/
if (alpha == 0.0)
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= beta;
return ierr;
}
/*-----------------------------------------------------------------------
* y = (beta/alpha)*y
*-----------------------------------------------------------------------*/
temp = beta / alpha;
if (temp != 1.0)
{
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= temp;
}
}
/*-----------------------------------------------------------------
* y += A*x
*-----------------------------------------------------------------*/
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i,jj) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
{
if (CF_marker_x[i] == fpt)
{
temp = y_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
if (CF_marker_y[A_j[jj]] == fpt) temp += A_data[jj] * x_data[A_j[jj]];
y_data[i] = temp;
}
}
/*-----------------------------------------------------------------
* y = alpha*y
*-----------------------------------------------------------------*/
if (alpha != 1.0)
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= alpha;
}
return ierr;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | --------------------------------------------*/
if (alpha == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= beta;
return ierr;
}
/*-----------------------------------------------------------------------
* y = (beta/alpha)*y
*-----------------------------------------------------------------------*/
temp = beta / alpha;
if (temp != 1.0)
{
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= temp;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | = beta / alpha;
if (temp != 1.0)
{
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | if (CF_marker_x[i] == fpt) y_data[i] = 0.0;
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
if (CF_marker_x[i] == fpt) y_data[i] *= temp;
}
}
/*-----------------------------------------------------------------
* y += A*x
*-----------------------------------------------------------------*/
#ifdef HYPRE_USING_OPENMP
#pragma omp parallel for private(i,jj) HYPRE_SMP_SCHEDULE
for (i = 0; i < num_rows; i++)
{
if (CF_marker_x[i] == fpt)
{
temp = y_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
if (CF_marker_y[A_j[jj]] == fpt) temp += A_data[jj] * x_data[A_j[jj]];
y_data[i] = temp;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AMG/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,jj) HYPRE_SMP_SCHEDULE | 100 | *-----------------------------------------------------------------*/
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
if (CF_marker_x[i] == fpt)
{
temp = y_data[i];
for (jj = A_i[i]; jj < A_i[i+1]; jj++)
if (CF_marker_y[A_j[jj]] == fpt) temp += A_data[jj] * x_data[A_j[jj]];
y_data[i] = temp;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,jj) HYPRE_SMP_SCHEDULE<OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/dataracebench/DRB058-jacobikernel-orig-no.c | #pragma omp parallel for private(i,j,xx,yy) | 100 | xx, yy;
dx = 2.0 / (n - 1);
dy = 2.0 / (m - 1);
/* Initialize initial condition and RHS */
//<LOOP-START>for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
{
xx = (int) (-1.0 + dx * (i - 1)); /* -1 < x < 1 */
yy = (int) (-1.0 + dy * (j - 1)); /* -1 < y < 1 */
u[i][j] = 0.0;
f[i][j] = -1.0 * alpha * (1.0 - xx * xx) * (1.0 - yy * yy)
- 2.0 * (1.0 - xx * xx) - 2.0 * (1.0 - yy * yy);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,xx,yy)<OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/BT/bt.c | #pragma omp parallel for firstprivate(dx1tx1 ,tx2 ,dx2tx1 ,xxcon1 ,c2 ,dx3tx1 ,xxcon2 ,dx4tx1 ,dx5tx1 ,xxcon5 ,xxcon4 ,xxcon3 ,c1) | 100 | es
c-------------------------------------------------------------------*/
//<LOOP-START>for (j = 1; j < grid_points[1]-1; j++) {
eta = (double)j * dnym1;
for (k = 1; k < grid_points[2]-1; k++) {
zeta = (double)k * dnzm1;
for (i = 0; i < grid_points[0]; i++) {
xi = (double)i * dnxm1;
exact_solution(xi, eta, zeta, dtemp);
for (m = 0; m < 5; m++) {
ue[i][m] = dtemp[m];
}
dtpp = 1.0 / dtemp[0];
for (m = 1; m <= 4; m++) {
buf[i][m] = dtpp * dtemp[m];
}
cuf[i] = buf[i][1] * buf[i][1];
buf[i][0] = cuf[i] + buf[i][2] * buf[i][2] +
buf[i][3] * buf[i][3];
q[i] = 0.5*(buf[i][1]*ue[i][1] + buf[i][2]*ue[i][2] +
buf[i][3]*ue[i][3]);
}
for (i = 1; i < grid_points[0]-1; i++) {
im1 = i-1;
ip1 = i+1;
forcing[i][j][k][0] = forcing[i][j][k][0] -
tx2*(ue[ip1][1]-ue[im1][1])+
dx1tx1*(ue[ip1][0]-2.0*ue[i][0]+ue[im1][0]);
forcing[i][j][k][1] = forcing[i][j][k][1] -
tx2 * ((ue[ip1][1]*buf[ip1][1]+c2*(ue[ip1][4]-q[ip1]))-
(ue[im1][1]*buf[im1][1]+c2*(ue[im1][4]-q[im1])))+
xxcon1*(buf[ip1][1]-2.0*buf[i][1]+buf[im1][1])+
dx2tx1*( ue[ip1][1]-2.0* ue[i][1]+ ue[im1][1]);
forcing[i][j][k][2] = forcing[i][j][k][2] -
tx2 * (ue[ip1][2]*buf[ip1][1]-ue[im1][2]*buf[im1][1])+
xxcon2*(buf[ip1][2]-2.0*buf[i][2]+buf[im1][2])+
dx3tx1*( ue[ip1][2]-2.0* ue[i][2]+ ue[im1][2]);
forcing[i][j][k][3] = forcing[i][j][k][3] -
tx2*(ue[ip1][3]*buf[ip1][1]-ue[im1][3]*buf[im1][1])+
xxcon2*(buf[ip1][3]-2.0*buf[i][3]+buf[im1][3])+
dx4tx1*( ue[ip1][3]-2.0* ue[i][3]+ ue[im1][3]);
forcing[i][j][k][4] = forcing[i][j][k][4] -
tx2*(buf[ip1][1]*(c1*ue[ip1][4]-c2*q[ip1])-
buf[im1][1]*(c1*ue[im1][4]-c2*q[im1]))+
0.5*xxcon3*(buf[ip1][0]-2.0*buf[i][0]+buf[im1][0])+
xxcon4*(cuf[ip1]-2.0*cuf[i]+cuf[im1])+
xxcon5*(buf[ip1][4]-2.0*buf[i][4]+buf[im1][4])+
dx5tx1*( ue[ip1][4]-2.0* ue[i][4]+ ue[im1][4]);
}
/*--------------------------------------------------------------------
c Fourth-order dissipation
c-------------------------------------------------------------------*/
for (m = 0; m < 5; m++) {
i = 1;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(5.0*ue[i][m] - 4.0*ue[i+1][m] +ue[i+2][m]);
i = 2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(-4.0*ue[i-1][m] + 6.0*ue[i][m] -
4.0*ue[i+1][m] + ue[i+2][m]);
}
for (m = 0; m < 5; m++) {
for (i = 1*3; i <= grid_points[0]-3*1-1; i++) {
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp*
(ue[i-2][m] - 4.0*ue[i-1][m] +
6.0*ue[i][m] - 4.0*ue[i+1][m] + ue[i+2][m]);
}
}
for (m = 0; m < 5; m++) {
i = grid_points[0]-3;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[i-2][m] - 4.0*ue[i-1][m] +
6.0*ue[i][m] - 4.0*ue[i+1][m]);
i = grid_points[0]-2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[i-2][m] - 4.0*ue[i-1][m] + 5.0*ue[i][m]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(dx1tx1 ,tx2 ,dx2tx1 ,xxcon1 ,c2 ,dx3tx1 ,xxcon2 ,dx4tx1 ,dx5tx1 ,xxcon5 ,xxcon4 ,xxcon3 ,c1)<OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/BT/bt.c | #pragma omp parallel for private(xi, zeta, eta) | 100 | differences
c-------------------------------------------------------------------*/
//<LOOP-START>for (i = 1; i < grid_points[0]-1; i++) {
xi = (double)i * dnxm1;
for (k = 1; k < grid_points[2]-1; k++) {
zeta = (double)k * dnzm1;
for (j = 0; j < grid_points[1]; j++) {
eta = (double)j * dnym1;
exact_solution(xi, eta, zeta, dtemp);
for (m = 0; m < 5; m++) {
ue[j][m] = dtemp[m];
}
dtpp = 1.0/dtemp[0];
for (m = 1; m <= 4; m++) {
buf[j][m] = dtpp * dtemp[m];
}
cuf[j] = buf[j][2] * buf[j][2];
buf[j][0] = cuf[j] + buf[j][1] * buf[j][1] +
buf[j][3] * buf[j][3];
q[j] = 0.5*(buf[j][1]*ue[j][1] + buf[j][2]*ue[j][2] +
buf[j][3]*ue[j][3]);
}
for (j = 1; j < grid_points[1]-1; j++) {
jm1 = j-1;
jp1 = j+1;
forcing[i][j][k][0] = forcing[i][j][k][0] -
ty2*( ue[jp1][2]-ue[jm1][2] )+
dy1ty1*(ue[jp1][0]-2.0*ue[j][0]+ue[jm1][0]);
forcing[i][j][k][1] = forcing[i][j][k][1] -
ty2*(ue[jp1][1]*buf[jp1][2]-ue[jm1][1]*buf[jm1][2])+
yycon2*(buf[jp1][1]-2.0*buf[j][1]+buf[jm1][1])+
dy2ty1*( ue[jp1][1]-2.0* ue[j][1]+ ue[jm1][1]);
forcing[i][j][k][2] = forcing[i][j][k][2] -
ty2*((ue[jp1][2]*buf[jp1][2]+c2*(ue[jp1][4]-q[jp1]))-
(ue[jm1][2]*buf[jm1][2]+c2*(ue[jm1][4]-q[jm1])))+
yycon1*(buf[jp1][2]-2.0*buf[j][2]+buf[jm1][2])+
dy3ty1*( ue[jp1][2]-2.0*ue[j][2] +ue[jm1][2]);
forcing[i][j][k][3] = forcing[i][j][k][3] -
ty2*(ue[jp1][3]*buf[jp1][2]-ue[jm1][3]*buf[jm1][2])+
yycon2*(buf[jp1][3]-2.0*buf[j][3]+buf[jm1][3])+
dy4ty1*( ue[jp1][3]-2.0*ue[j][3]+ ue[jm1][3]);
forcing[i][j][k][4] = forcing[i][j][k][4] -
ty2*(buf[jp1][2]*(c1*ue[jp1][4]-c2*q[jp1])-
buf[jm1][2]*(c1*ue[jm1][4]-c2*q[jm1]))+
0.5*yycon3*(buf[jp1][0]-2.0*buf[j][0]+
buf[jm1][0])+
yycon4*(cuf[jp1]-2.0*cuf[j]+cuf[jm1])+
yycon5*(buf[jp1][4]-2.0*buf[j][4]+buf[jm1][4])+
dy5ty1*(ue[jp1][4]-2.0*ue[j][4]+ue[jm1][4]);
}
/*--------------------------------------------------------------------
c Fourth-order dissipation
c-------------------------------------------------------------------*/
for (m = 0; m < 5; m++) {
j = 1;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(5.0*ue[j][m] - 4.0*ue[j+1][m] +ue[j+2][m]);
j = 2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(-4.0*ue[j-1][m] + 6.0*ue[j][m] -
4.0*ue[j+1][m] + ue[j+2][m]);
}
for (m = 0; m < 5; m++) {
for (j = 1*3; j <= grid_points[1]-3*1-1; j++) {
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp*
(ue[j-2][m] - 4.0*ue[j-1][m] +
6.0*ue[j][m] - 4.0*ue[j+1][m] + ue[j+2][m]);
}
}
for (m = 0; m < 5; m++) {
j = grid_points[1]-3;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[j-2][m] - 4.0*ue[j-1][m] +
6.0*ue[j][m] - 4.0*ue[j+1][m]);
j = grid_points[1]-2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[j-2][m] - 4.0*ue[j-1][m] + 5.0*ue[j][m]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(xi, zeta, eta) <OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/BT/bt.c | #pragma omp parallel for private(xi, eta, zeta) | 100 | es
c-------------------------------------------------------------------*/
//<LOOP-START>for (i = 1; i < grid_points[0]-1; i++) {
xi = (double)i * dnxm1;
for (j = 1; j < grid_points[1]-1; j++) {
eta = (double)j * dnym1;
for (k = 0; k < grid_points[2]; k++) {
zeta = (double)k * dnzm1;
exact_solution(xi, eta, zeta, dtemp);
for (m = 0; m < 5; m++) {
ue[k][m] = dtemp[m];
}
dtpp = 1.0/dtemp[0];
for (m = 1; m <= 4; m++) {
buf[k][m] = dtpp * dtemp[m];
}
cuf[k] = buf[k][3] * buf[k][3];
buf[k][0] = cuf[k] + buf[k][1] * buf[k][1] +
buf[k][2] * buf[k][2];
q[k] = 0.5*(buf[k][1]*ue[k][1] + buf[k][2]*ue[k][2] +
buf[k][3]*ue[k][3]);
}
for (k = 1; k < grid_points[2]-1; k++) {
km1 = k-1;
kp1 = k+1;
forcing[i][j][k][0] = forcing[i][j][k][0] -
tz2*( ue[kp1][3]-ue[km1][3] )+
dz1tz1*(ue[kp1][0]-2.0*ue[k][0]+ue[km1][0]);
forcing[i][j][k][1] = forcing[i][j][k][1] -
tz2 * (ue[kp1][1]*buf[kp1][3]-ue[km1][1]*buf[km1][3])+
zzcon2*(buf[kp1][1]-2.0*buf[k][1]+buf[km1][1])+
dz2tz1*( ue[kp1][1]-2.0* ue[k][1]+ ue[km1][1]);
forcing[i][j][k][2] = forcing[i][j][k][2] -
tz2 * (ue[kp1][2]*buf[kp1][3]-ue[km1][2]*buf[km1][3])+
zzcon2*(buf[kp1][2]-2.0*buf[k][2]+buf[km1][2])+
dz3tz1*(ue[kp1][2]-2.0*ue[k][2]+ue[km1][2]);
forcing[i][j][k][3] = forcing[i][j][k][3] -
tz2 * ((ue[kp1][3]*buf[kp1][3]+c2*(ue[kp1][4]-q[kp1]))-
(ue[km1][3]*buf[km1][3]+c2*(ue[km1][4]-q[km1])))+
zzcon1*(buf[kp1][3]-2.0*buf[k][3]+buf[km1][3])+
dz4tz1*( ue[kp1][3]-2.0*ue[k][3] +ue[km1][3]);
forcing[i][j][k][4] = forcing[i][j][k][4] -
tz2 * (buf[kp1][3]*(c1*ue[kp1][4]-c2*q[kp1])-
buf[km1][3]*(c1*ue[km1][4]-c2*q[km1]))+
0.5*zzcon3*(buf[kp1][0]-2.0*buf[k][0]
+buf[km1][0])+
zzcon4*(cuf[kp1]-2.0*cuf[k]+cuf[km1])+
zzcon5*(buf[kp1][4]-2.0*buf[k][4]+buf[km1][4])+
dz5tz1*( ue[kp1][4]-2.0*ue[k][4]+ ue[km1][4]);
}
/*--------------------------------------------------------------------
c Fourth-order dissipation
c-------------------------------------------------------------------*/
for (m = 0; m < 5; m++) {
k = 1;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(5.0*ue[k][m] - 4.0*ue[k+1][m] +ue[k+2][m]);
k = 2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(-4.0*ue[k-1][m] + 6.0*ue[k][m] -
4.0*ue[k+1][m] + ue[k+2][m]);
}
for (m = 0; m < 5; m++) {
for (k = 1*3; k <= grid_points[2]-3*1-1; k++) {
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp*
(ue[k-2][m] - 4.0*ue[k-1][m] +
6.0*ue[k][m] - 4.0*ue[k+1][m] + ue[k+2][m]);
}
}
for (m = 0; m < 5; m++) {
k = grid_points[2]-3;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[k-2][m] - 4.0*ue[k-1][m] +
6.0*ue[k][m] - 4.0*ue[k+1][m]);
k = grid_points[2]-2;
forcing[i][j][k][m] = forcing[i][j][k][m] - dssp *
(ue[k-2][m] - 4.0*ue[k-1][m] + 5.0*ue[k][m]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(xi, eta, zeta)<OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/BT/bt.c | #pragma omp parallel for private(tmp1, tmp2, tmp3) | 100 | led f) and s jacobians
c---------------------------------------------------------------------*/
//<LOOP-START>for (i = 1; i < grid_points[0]-1; i++) {
for (j = 1; j < grid_points[1]-1; j++) {
for (k = 0; k < grid_points[2]; k++) {
tmp1 = 1.0 / u[i][j][k][0];
tmp2 = tmp1 * tmp1;
tmp3 = tmp1 * tmp2;
fjac[i][j][k][0][0] = 0.0;
fjac[i][j][k][0][1] = 0.0;
fjac[i][j][k][0][2] = 0.0;
fjac[i][j][k][0][3] = 1.0;
fjac[i][j][k][0][4] = 0.0;
fjac[i][j][k][1][0] = - ( u[i][j][k][1]*u[i][j][k][3] )
* tmp2;
fjac[i][j][k][1][1] = u[i][j][k][3] * tmp1;
fjac[i][j][k][1][2] = 0.0;
fjac[i][j][k][1][3] = u[i][j][k][1] * tmp1;
fjac[i][j][k][1][4] = 0.0;
fjac[i][j][k][2][0] = - ( u[i][j][k][2]*u[i][j][k][3] )
* tmp2;
fjac[i][j][k][2][1] = 0.0;
fjac[i][j][k][2][2] = u[i][j][k][3] * tmp1;
fjac[i][j][k][2][3] = u[i][j][k][2] * tmp1;
fjac[i][j][k][2][4] = 0.0;
fjac[i][j][k][3][0] = - (u[i][j][k][3]*u[i][j][k][3] * tmp2 )
+ 0.50 * c2 * ( ( u[i][j][k][1] * u[i][j][k][1]
+ u[i][j][k][2] * u[i][j][k][2]
+ u[i][j][k][3] * u[i][j][k][3] ) * tmp2 );
fjac[i][j][k][3][1] = - c2 * u[i][j][k][1] * tmp1;
fjac[i][j][k][3][2] = - c2 * u[i][j][k][2] * tmp1;
fjac[i][j][k][3][3] = ( 2.0 - c2 )
* u[i][j][k][3] * tmp1;
fjac[i][j][k][3][4] = c2;
fjac[i][j][k][4][0] = ( c2 * ( u[i][j][k][1] * u[i][j][k][1]
+ u[i][j][k][2] * u[i][j][k][2]
+ u[i][j][k][3] * u[i][j][k][3] )
* tmp2
- c1 * ( u[i][j][k][4] * tmp1 ) )
* ( u[i][j][k][3] * tmp1 );
fjac[i][j][k][4][1] = - c2 * ( u[i][j][k][1]*u[i][j][k][3] )
* tmp2;
fjac[i][j][k][4][2] = - c2 * ( u[i][j][k][2]*u[i][j][k][3] )
* tmp2;
fjac[i][j][k][4][3] = c1 * ( u[i][j][k][4] * tmp1 )
- 0.50 * c2
* ( ( u[i][j][k][1]*u[i][j][k][1]
+ u[i][j][k][2]*u[i][j][k][2]
+ 3.0*u[i][j][k][3]*u[i][j][k][3] )
* tmp2 );
fjac[i][j][k][4][4] = c1 * u[i][j][k][3] * tmp1;
njac[i][j][k][0][0] = 0.0;
njac[i][j][k][0][1] = 0.0;
njac[i][j][k][0][2] = 0.0;
njac[i][j][k][0][3] = 0.0;
njac[i][j][k][0][4] = 0.0;
njac[i][j][k][1][0] = - c3c4 * tmp2 * u[i][j][k][1];
njac[i][j][k][1][1] = c3c4 * tmp1;
njac[i][j][k][1][2] = 0.0;
njac[i][j][k][1][3] = 0.0;
njac[i][j][k][1][4] = 0.0;
njac[i][j][k][2][0] = - c3c4 * tmp2 * u[i][j][k][2];
njac[i][j][k][2][1] = 0.0;
njac[i][j][k][2][2] = c3c4 * tmp1;
njac[i][j][k][2][3] = 0.0;
njac[i][j][k][2][4] = 0.0;
njac[i][j][k][3][0] = - con43 * c3c4 * tmp2 * u[i][j][k][3];
njac[i][j][k][3][1] = 0.0;
njac[i][j][k][3][2] = 0.0;
njac[i][j][k][3][3] = con43 * c3 * c4 * tmp1;
njac[i][j][k][3][4] = 0.0;
njac[i][j][k][4][0] = - ( c3c4
- c1345 ) * tmp3 * (pow2(u[i][j][k][1]))
- ( c3c4 - c1345 ) * tmp3 * (pow2(u[i][j][k][2]))
- ( con43 * c3c4
- c1345 ) * tmp3 * (pow2(u[i][j][k][3]))
- c1345 * tmp2 * u[i][j][k][4];
njac[i][j][k][4][1] = ( c3c4 - c1345 ) * tmp2 * u[i][j][k][1];
njac[i][j][k][4][2] = ( c3c4 - c1345 ) * tmp2 * u[i][j][k][2];
njac[i][j][k][4][3] = ( con43 * c3c4
- c1345 ) * tmp2 * u[i][j][k][3];
njac[i][j][k][4][4] = ( c1345 )* tmp1;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(tmp1, tmp2, tmp3) <OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | -----*/
int i, j, k, d, m;
double add;
for (m = 0; m < 5; m++) {
rms[m] = 0.0;
}
//<LOOP-START>for (i = 0; i <= grid_points[0]-2; i++) {
//#pragma omp parallel for
for (j = 0; j <= grid_points[1]-2; j++) {
//#pragma omp parallel for
for (k = 0; k <= grid_points[2]-2; k++) {
for (m = 0; m < 5; m++) {
add = rhs[m][i][j][k];
rms[m] = rms[m] + add*add;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | rms[m] = 0.0;
}
//#pragma omp parallel for
for (i = 0; i <= grid_points[0]-2; i++) {
//<LOOP-START>for (j = 0; j <= grid_points[1]-2; j++) {
//#pragma omp parallel for
for (k = 0; k <= grid_points[2]-2; k++) {
for (m = 0; m < 5; m++) {
add = rhs[m][i][j][k];
rms[m] = rms[m] + add*add;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/NPB3.0-omp-c/SP/sp.c | #pragma omp parallel for | 100 | 0]-2; i++) {
//#pragma omp parallel for
for (j = 0; j <= grid_points[1]-2; j++) {
//<LOOP-START>for (k = 0; k <= grid_points[2]-2; k++) {
for (m = 0; m < 5; m++) {
add = rhs[m][i][j][k];
rms[m] = rms[m] + add*add;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
LLNL/AutoParBench/benchmarks/sequential/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 | double qq[NQ]; /* private copy of q[0:NQ-1] */
for (i = 0; i < NQ; i++) qq[i] = 0.0;
//<LOOP-START>for (k = 1; k <= np; k++) {
kk = k_offset + k;
t1 = S;
t2 = an;
/* Find starting seed t1 for this kk. */
for (i = 1; i <= 100; i++) {
ik = kk / 2;
if (2 * ik != kk) t3 = randlc(&t1, t2);
if (ik == 0) break;
t3 = randlc(&t2, t2);
kk = ik;
}
/* Compute uniform pseudorandom numbers. */
if (TIMERS_ENABLED == TRUE) timer_start(3);
vranlc(2*NK, &t1, A, x-1);
if (TIMERS_ENABLED == TRUE) timer_stop(3);
/*
c Compute Gaussian deviates by acceptance-rejection method and
c tally counts in concentric square annuli. This loop is not
c vectorizable.
*/
if (TIMERS_ENABLED == TRUE) timer_start(2);
for ( i = 0; i < NK; i++) {
x1 = 2.0 * x[2*i] - 1.0;
x2 = 2.0 * x[2*i+1] - 1.0;
t1 = pow2(x1) + pow2(x2);
if (t1 <= 1.0) {
t2 = sqrt(-2.0 * log(t1) / t1);
t3 = (x1 * t2); /* Xi */
t4 = (x2 * t2); /* Yi */
l = max(fabs(t3), fabs(t4));
qq[l] += 1.0; /* counts */
sx = sx + t3; /* sum of Xi */
sy = sy + t4; /* sum of Yi */
}
}
if (TIMERS_ENABLED == TRUE) timer_stop(2);
}<LOOP-END> <OMP-START>#pragma omp parallel for copyin(x, qq) private(x1, x2, t1, t2, t3, t4, ik, kk, i, l) reduction(+:sx) reduction(+:sy) <OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c1, c2) | 100 | uble B[500 + 0][500 + 0])
{
//int i;
//int j;
{
int c1;
int c2;
if (n >= 1) {
<LOOP-START>for (c1 = 0; c1 <= n + -1; c1++) {
#pragma omp parallel for private(c2)
for (c2 = 0; c2 <= n + -1; c2++) {
X[c1][c2] = (((double )c1) * (c2 + 1) + 1) / n;
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c2) | 100 | ) {
#pragma omp parallel for private(c1, c2)
for (c1 = 0; c1 <= n + -1; c1++) {
<LOOP-START>for (c2 = 0; c2 <= n + -1; c2++) {
X[c1][c2] = (((double )c1) * (c2 + 1) + 1) / n;
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c2, c8) | 100 | ;
//#pragma scop
{
int c0;
int c2;
int c8;
for (c0 = 0; c0 <= 9; c0++) {
<LOOP-START>for (c2 = 0; c2 <= 499; c2++) {
for (c8 = 1; c8 <= 499; c8++) {
B[c2][c8] = B[c2][c8] - A[c2][c8] * A[c2][c8] / B[c2][c8 - 1];
}
for (c8 = 1; c8 <= 499; c8++) {
X[c2][c8] = X[c2][c8] - X[c2][c8 - 1] * A[c2][c8] / B[c2][c8 - 1];
}
for (c8 = 0; c8 <= 497; c8++) {
X[c2][500 - c8 - 2] = (X[c2][500 - 2 - c8] - X[c2][500 - 2 - c8 - 1] * A[c2][500 - c8 - 3]) / B[c2][500 - 3 - c8];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c2) | 100 | c8] - X[c2][500 - 2 - c8 - 1] * A[c2][500 - c8 - 3]) / B[c2][500 - 3 - c8];
}
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2++) {
X[c2][500 - 1] = X[c2][500 - 1] / B[c2][500 - 1];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c2, c8) | 100 | (c2 = 0; c2 <= 499; c2++) {
X[c2][500 - 1] = X[c2][500 - 1] / B[c2][500 - 1];
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2++) {
for (c8 = 1; c8 <= 499; c8++) {
B[c8][c2] = B[c8][c2] - A[c8][c2] * A[c8][c2] / B[c8 - 1][c2];
}
for (c8 = 1; c8 <= 499; c8++) {
X[c8][c2] = X[c8][c2] - X[c8 - 1][c2] * A[c8][c2] / B[c8 - 1][c2];
}
for (c8 = 0; c8 <= 497; c8++) {
X[500 - 2 - c8][c2] = (X[500 - 2 - c8][c2] - X[500 - c8 - 3][c2] * A[500 - 3 - c8][c2]) / B[500 - 2 - c8][c2];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB043-adi-parallel-no.c | #pragma omp parallel for private(c2) | 100 | c8][c2] - X[500 - c8 - 3][c2] * A[500 - 3 - c8][c2]) / B[500 - 2 - c8][c2];
}
}
<LOOP-START>for (c2 = 0; c2 <= 499; c2++) {
X[500 - 1][c2] = X[500 - 1][c2] / B[500 - 1][c2];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for | 100 | int argc, char* argv[])
{
int i,j;
float temp, sum=0.0;
int len=100;
float u[100][100];
<LOOP-START>for (i = 0; i < len; i++)
#pragma omp parallel for
for (j = 0; j < len; j++)
u[i][j] = 0.5;
#pragma omp parallel for private(temp) reduction(+:sum)
for (i = 0; i < len; i++)
#pragma omp parallel for private(temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for | 100 | ;
int len=100;
float u[100][100];
#pragma omp parallel for
for (i = 0; i < len; i++)
<LOOP-START>for (j = 0; j < len; j++)
u[i][j] = 0.5;
#pragma omp parallel for private(temp) reduction(+:sum)
for (i = 0; i < len; i++)
#pragma omp parallel for private(temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private(temp) reduction(+:sum) | 100 | < len; i++)
#pragma omp parallel for
for (j = 0; j < len; j++)
u[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len; i++)
#pragma omp parallel for private(temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(temp) reduction(+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB021-reductionmissing-orig-yes.c | #pragma omp parallel for private(temp) reduction(+:sum) | 100 | = 0.5;
#pragma omp parallel for private(temp) reduction(+:sum)
for (i = 0; i < len; i++)
<LOOP-START>for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(temp) reduction(+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB019-plusplus-var-yes.c | #pragma omp parallel for | 100 | outLen = 0;
if (argc>1)
inLen= atoi(argv[1]);
int input[inLen];
int output[inLen];
<LOOP-START>for (i=0; i<inLen; ++i)
input[i]=i;
#pragma omp parallel for linear(outLen)
for (i=0; i<inLen; ++i) {
output[outLen++] = input[i] ;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB019-plusplus-var-yes.c | #pragma omp parallel for linear(outLen) | 100 |
int output[inLen];
#pragma omp parallel for
for (i=0; i<inLen; ++i)
input[i]=i;
<LOOP-START>for (i=0; i<inLen; ++i) {
output[outLen++] = input[i] ;
}<LOOP-END> <OMP-START>#pragma omp parallel for linear(outLen)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB012-minusminus-var-yes.c | #pragma omp parallel for | 100 | n=100;
if (argc>1)
len = atoi(argv[1]);
int numNodes=len, numNodes2=0;
int x[len];
<LOOP-START>for (i=0; i< len; i++)
{
if (i%2==0)
x[i]=5;
else
x[i]= -5;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB012-minusminus-var-yes.c | #pragma omp parallel for reduction(-:numNodes2) | 100 | llel for
for (i=0; i< len; i++)
{
if (i%2==0)
x[i]=5;
else
x[i]= -5;
}
<LOOP-START>for (i=numNodes-1 ; i>-1 ; --i) {
if (x[i]<=0) {
numNodes2-- ;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(-:numNodes2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB022-reductionmissing-var-yes.c | #pragma omp parallel for | 100 | float temp, sum=0.0;
int len=100;
if (argc>1)
len = atoi(argv[1]);
float u[len][len];
<LOOP-START>for (i = 0; i < len; i++)
#pragma omp parallel for
for (j = 0; j < len; j++)
u[i][j] = 0.5;
#pragma omp parallel for private (temp) reduction(+:sum)
for (i = 0; i < len; i++)
#pragma omp parallel for private (temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB022-reductionmissing-var-yes.c | #pragma omp parallel for | 100 | n = atoi(argv[1]);
float u[len][len];
#pragma omp parallel for
for (i = 0; i < len; i++)
<LOOP-START>for (j = 0; j < len; j++)
u[i][j] = 0.5;
#pragma omp parallel for private (temp) reduction(+:sum)
for (i = 0; i < len; i++)
#pragma omp parallel for private (temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB022-reductionmissing-var-yes.c | #pragma omp parallel for private (temp) reduction(+:sum) | 100 | i < len; i++)
#pragma omp parallel for
for (j = 0; j < len; j++)
u[i][j] = 0.5;
<LOOP-START>for (i = 0; i < len; i++)
#pragma omp parallel for private (temp) reduction(+:sum)
for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp) reduction(+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB022-reductionmissing-var-yes.c | #pragma omp parallel for private (temp) reduction(+:sum) | 100 | = 0.5;
#pragma omp parallel for private (temp) reduction(+:sum)
for (i = 0; i < len; i++)
<LOOP-START>for (j = 0; j < len; j++)
{
temp = u[i][j];
sum = sum + temp * temp;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (temp) reduction(+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB056-jacobi2d-tile-no.c | #pragma omp parallel for private(c1, c3, c4, c2) | 100 | )
{
//int i;
//int j;
{
int c1;
int c2;
int c4;
int c3;
if (n >= 1) {
<LOOP-START>for (c1 = 0; c1 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c1++) {
#pragma omp parallel for private(c2, c3, c4)
for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for private(c3, c4)
for (c3 = 16 * c2; c3 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c1; c4 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c4++) {
A[c4][c3] = (((double )c4) * (c3 + 2) + 2) / n;
B[c4][c3] = (((double )c4) * (c3 + 3) + 3) / n;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c3, c4, c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB056-jacobi2d-tile-no.c | #pragma omp parallel for private(c2, c3, c4) | 100 | 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c1++) {
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for private(c3, c4)
for (c3 = 16 * c2; c3 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c1; c4 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c4++) {
A[c4][c3] = (((double )c4) * (c3 + 2) + 2) / n;
B[c4][c3] = (((double )c4) * (c3 + 3) + 3) / n;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c3, c4)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB056-jacobi2d-tile-no.c | #pragma omp parallel for private(c3, c4) | 100 | ?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
<LOOP-START>for (c3 = 16 * c2; c3 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c1; c4 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c4++) {
A[c4][c3] = (((double )c4) * (c3 + 2) + 2) / n;
B[c4][c3] = (((double )c4) * (c3 + 3) + 3) / n;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c3, c4)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB056-jacobi2d-tile-no.c | #pragma omp parallel for private(c4) | 100 | for (c3 = 16 * c2; c3 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c3++) {
<LOOP-START>for (c4 = 16 * c1; c4 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c4++) {
A[c4][c3] = (((double )c4) * (c3 + 2) + 2) / n;
B[c4][c3] = (((double )c4) * (c3 + 3) + 3) / n;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c4)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB056-jacobi2d-tile-no.c | #pragma omp parallel for private(c1, c5, c4, c2, c3) | 100 | 16 + 1) / 16) : -((-(n + 3 * tsteps + -4) + 16 - 1) / 16))) : (n + 3 * tsteps + -4) / 16)); c0++) {
<LOOP-START>for (c1 = (((2 * c0 * 3 < 0?-(-(2 * c0) / 3) : ((3 < 0?(-(2 * c0) + - 3 - 1) / - 3 : (2 * c0 + 3 - 1) / 3)))) > (((16 * c0 + -1 * tsteps + 1) * 16 < 0?-(-(16 * c0 + -1 * tsteps + 1) / 16) : ((16 < 0?(-(16 * c0 + -1 * tsteps + 1) + - 16 - 1) / - 16 : (16 * c0 + -1 * tsteps + 1 + 16 - 1) / 16))))?((2 * c0 * 3 < 0?-(-(2 * c0) / 3) : ((3 < 0?(-(2 * c0) + - 3 - 1) / - 3 : (2 * c0 + 3 - 1) / 3)))) : (((16 * c0 + -1 * tsteps + 1) * 16 < 0?-(-(16 * c0 + -1 * tsteps + 1) / 16) : ((16 < 0?(-(16 * c0 + -1 * tsteps + 1) + - 16 - 1) / - 16 : (16 * c0 + -1 * tsteps + 1 + 16 - 1) / 16))))); c1 <= (((((((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)) < (((32 * c0 + n + 29) * 48 < 0?((48 < 0?-((-(32 * c0 + n + 29) + 48 + 1) / 48) : -((-(32 * c0 + n + 29) + 48 - 1) / 48))) : (32 * c0 + n + 29) / 48))?(((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)) : (((32 * c0 + n + 29) * 48 < 0?((48 < 0?-((-(32 * c0 + n + 29) + 48 + 1) / 48) : -((-(32 * c0 + n + 29) + 48 - 1) / 48))) : (32 * c0 + n + 29) / 48)))) < c0?(((((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)) < (((32 * c0 + n + 29) * 48 < 0?((48 < 0?-((-(32 * c0 + n + 29) + 48 + 1) / 48) : -((-(32 * c0 + n + 29) + 48 - 1) / 48))) : (32 * c0 + n + 29) / 48))?(((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)) : (((32 * c0 + n + 29) * 48 < 0?((48 < 0?-((-(32 * c0 + n + 29) + 48 + 1) / 48) : -((-(32 * c0 + n + 29) + 48 - 1) / 48))) : (32 * c0 + n + 29) / 48)))) : c0)); c1++) {
for (c2 = ((((16 * c1 + -1 * n + -12) * 16 < 0?-(-(16 * c1 + -1 * n + -12) / 16) : ((16 < 0?(-(16 * c1 + -1 * n + -12) + - 16 - 1) / - 16 : (16 * c1 + -1 * n + -12 + 16 - 1) / 16)))) > 2 * c0 + -2 * c1?(((16 * c1 + -1 * n + -12) * 16 < 0?-(-(16 * c1 + -1 * n + -12) / 16) : ((16 < 0?(-(16 * c1 + -1 * n + -12) + - 16 - 1) / - 16 : (16 * c1 + -1 * n + -12 + 16 - 1) / 16)))) : 2 * c0 + -2 * c1); c2 <= (((((((16 * c1 + n + 12) * 16 < 0?((16 < 0?-((-(16 * c1 + n + 12) + 16 + 1) / 16) : -((-(16 * c1 + n + 12) + 16 - 1) / 16))) : (16 * c1 + n + 12) / 16)) < (((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16))?(((16 * c1 + n + 12) * 16 < 0?((16 < 0?-((-(16 * c1 + n + 12) + 16 + 1) / 16) : -((-(16 * c1 + n + 12) + 16 - 1) / 16))) : (16 * c1 + n + 12) / 16)) : (((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)))) < (((32 * c0 + -32 * c1 + n + 29) * 16 < 0?((16 < 0?-((-(32 * c0 + -32 * c1 + n + 29) + 16 + 1) / 16) : -((-(32 * c0 + -32 * c1 + n + 29) + 16 - 1) / 16))) : (32 * c0 + -32 * c1 + n + 29) / 16))?(((((16 * c1 + n + 12) * 16 < 0?((16 < 0?-((-(16 * c1 + n + 12) + 16 + 1) / 16) : -((-(16 * c1 + n + 12) + 16 - 1) / 16))) : (16 * c1 + n + 12) / 16)) < (((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16))?(((16 * c1 + n + 12) * 16 < 0?((16 < 0?-((-(16 * c1 + n + 12) + 16 + 1) / 16) : -((-(16 * c1 + n + 12) + 16 - 1) / 16))) : (16 * c1 + n + 12) / 16)) : (((n + 2 * tsteps + -3) * 16 < 0?((16 < 0?-((-(n + 2 * tsteps + -3) + 16 + 1) / 16) : -((-(n + 2 * tsteps + -3) + 16 - 1) / 16))) : (n + 2 * tsteps + -3) / 16)))) : (((32 * c0 + -32 * c1 + n + 29) * 16 < 0?((16 < 0?-((-(32 * c0 + -32 * c1 + n + 29) + 16 + 1) / 16) : -((-(32 * c0 + -32 * c1 + n + 29) + 16 - 1) / 16))) : (32 * c0 + -32 * c1 + n + 29) / 16)))); c2++) {
if (c0 <= (((32 * c1 + 16 * c2 + -1 * n + 1) * 32 < 0?((32 < 0?-((-(32 * c1 + 16 * c2 + -1 * n + 1) + 32 + 1) / 32) : -((-(32 * c1 + 16 * c2 + -1 * n + 1) + 32 - 1) / 32))) : (32 * c1 + 16 * c2 + -1 * n + 1) / 32)) && c1 <= c2 + -1) {
if ((n + 1) % 2 == 0) {
for (c4 = (16 * c1 > 16 * c2 + -1 * n + 3?16 * c1 : 16 * c2 + -1 * n + 3); c4 <= 16 * c1 + 15; c4++) {
A[-16 * c2 + c4 + n + -2][n + -2] = B[-16 * c2 + c4 + n + -2][n + -2];
}
}
}
if (c0 <= (((48 * c1 + -1 * n + 1) * 32 < 0?((32 < 0?-((-(48 * c1 + -1 * n + 1) + 32 + 1) / 32) : -((-(48 * c1 + -1 * n + 1) + 32 - 1) / 32))) : (48 * c1 + -1 * n + 1) / 32)) && c1 >= c2) {
if ((n + 1) % 2 == 0) {
for (c5 = (16 * c2 > 16 * c1 + -1 * n + 3?16 * c2 : 16 * c1 + -1 * n + 3); c5 <= ((16 * c1 < 16 * c2 + 15?16 * c1 : 16 * c2 + 15)); c5++) {
A[n + -2][-16 * c1 + c5 + n + -2] = B[n + -2][-16 * c1 + c5 + n + -2];
}
}
}
for (c3 = ((((((16 * c1 + -1 * n + 2) * 2 < 0?-(-(16 * c1 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c1 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c1 + -1 * n + 2 + 2 - 1) / 2)))) > (((16 * c2 + -1 * n + 2) * 2 < 0?-(-(16 * c2 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c2 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c2 + -1 * n + 2 + 2 - 1) / 2))))?(((16 * c1 + -1 * n + 2) * 2 < 0?-(-(16 * c1 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c1 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c1 + -1 * n + 2 + 2 - 1) / 2)))) : (((16 * c2 + -1 * n + 2) * 2 < 0?-(-(16 * c2 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c2 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c2 + -1 * n + 2 + 2 - 1) / 2)))))) > 16 * c0 + -16 * c1?(((((16 * c1 + -1 * n + 2) * 2 < 0?-(-(16 * c1 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c1 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c1 + -1 * n + 2 + 2 - 1) / 2)))) > (((16 * c2 + -1 * n + 2) * 2 < 0?-(-(16 * c2 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c2 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c2 + -1 * n + 2 + 2 - 1) / 2))))?(((16 * c1 + -1 * n + 2) * 2 < 0?-(-(16 * c1 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c1 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c1 + -1 * n + 2 + 2 - 1) / 2)))) : (((16 * c2 + -1 * n + 2) * 2 < 0?-(-(16 * c2 + -1 * n + 2) / 2) : ((2 < 0?(-(16 * c2 + -1 * n + 2) + - 2 - 1) / - 2 : (16 * c2 + -1 * n + 2 + 2 - 1) / 2)))))) : 16 * c0 + -16 * c1); c3 <= ((((((8 * c1 + 6 < 8 * c2 + 6?8 * c1 + 6 : 8 * c2 + 6)) < tsteps + -1?((8 * c1 + 6 < 8 * c2 + 6?8 * c1 + 6 : 8 * c2 + 6)) : tsteps + -1)) < 16 * c0 + -16 * c1 + 15?((((8 * c1 + 6 < 8 * c2 + 6?8 * c1 + 6 : 8 * c2 + 6)) < tsteps + -1?((8 * c1 + 6 < 8 * c2 + 6?8 * c1 + 6 : 8 * c2 + 6)) : tsteps + -1)) : 16 * c0 + -16 * c1 + 15)); c3++) {
if (c1 <= ((c3 * 8 < 0?((8 < 0?-((-c3 + 8 + 1) / 8) : -((-c3 + 8 - 1) / 8))) : c3 / 8))) {
for (c5 = (16 * c2 > 2 * c3 + 1?16 * c2 : 2 * c3 + 1); c5 <= ((16 * c2 + 15 < 2 * c3 + n + -2?16 * c2 + 15 : 2 * c3 + n + -2)); c5++) {
B[1][-2 * c3 + c5] = 0.2 * (A[1][-2 * c3 + c5] + A[1][-2 * c3 + c5 - 1] + A[1][1 + (-2 * c3 + c5)] + A[1 + 1][-2 * c3 + c5] + A[1 - 1][-2 * c3 + c5]);
}
}
for (c4 = (16 * c1 > 2 * c3 + 2?16 * c1 : 2 * c3 + 2); c4 <= ((16 * c1 + 15 < 2 * c3 + n + -2?16 * c1 + 15 : 2 * c3 + n + -2)); c4++) {
if (c2 <= ((c3 * 8 < 0?((8 < 0?-((-c3 + 8 + 1) / 8) : -((-c3 + 8 - 1) / 8))) : c3 / 8))) {
B[-2 * c3 + c4][1] = 0.2 * (A[-2 * c3 + c4][1] + A[-2 * c3 + c4][1 - 1] + A[-2 * c3 + c4][1 + 1] + A[1 + (-2 * c3 + c4)][1] + A[-2 * c3 + c4 - 1][1]);
}
for (c5 = (16 * c2 > 2 * c3 + 2?16 * c2 : 2 * c3 + 2); c5 <= ((16 * c2 + 15 < 2 * c3 + n + -2?16 * c2 + 15 : 2 * c3 + n + -2)); c5++) {
B[-2 * c3 + c4][-2 * c3 + c5] = 0.2 * (A[-2 * c3 + c4][-2 * c3 + c5] + A[-2 * c3 + c4][-2 * c3 + c5 - 1] + A[-2 * c3 + c4][1 + (-2 * c3 + c5)] + A[1 + (-2 * c3 + c4)][-2 * c3 + c5] + A[-2 * c3 + c4 - 1][-2 * c3 + c5]);
A[-2 * c3 + c4 + -1][-2 * c3 + c5 + -1] = B[-2 * c3 + c4 + -1][-2 * c3 + c5 + -1];
}
if (c2 >= (((2 * c3 + n + -16) * 16 < 0?-(-(2 * c3 + n + -16) / 16) : ((16 < 0?(-(2 * c3 + n + -16) + - 16 - 1) / - 16 : (2 * c3 + n + -16 + 16 - 1) / 16))))) {
A[-2 * c3 + c4 + -1][n + -2] = B[-2 * c3 + c4 + -1][n + -2];
}
}
if (c1 >= (((2 * c3 + n + -16) * 16 < 0?-(-(2 * c3 + n + -16) / 16) : ((16 < 0?(-(2 * c3 + n + -16) + - 16 - 1) / - 16 : (2 * c3 + n + -16 + 16 - 1) / 16))))) {
for (c5 = (16 * c2 > 2 * c3 + 2?16 * c2 : 2 * c3 + 2); c5 <= ((16 * c2 + 15 < 2 * c3 + n + -1?16 * c2 + 15 : 2 * c3 + n + -1)); c5++) {
A[n + -2][-2 * c3 + c5 + -1] = B[n + -2][-2 * c3 + c5 + -1];
}
}
}
if (c0 >= (((2 * c1 + c2 + -1) * 2 < 0?-(-(2 * c1 + c2 + -1) / 2) : ((2 < 0?(-(2 * c1 + c2 + -1) + - 2 - 1) / - 2 : (2 * c1 + c2 + -1 + 2 - 1) / 2)))) && c1 >= c2 + 1 && c2 <= (((tsteps + -8) * 8 < 0?((8 < 0?-((-(tsteps + -8) + 8 + 1) / 8) : -((-(tsteps + -8) + 8 - 1) / 8))) : (tsteps + -8) / 8))) {
for (c4 = 16 * c1; c4 <= ((16 * c1 + 15 < 16 * c2 + n + 12?16 * c1 + 15 : 16 * c2 + n + 12)); c4++) {
B[-16 * c2 + c4 + -14][1] = 0.2 * (A[-16 * c2 + c4 + -14][1] + A[-16 * c2 + c4 + -14][1 - 1] + A[-16 * c2 + c4 + -14][1 + 1] + A[1 + (-16 * c2 + c4 + -14)][1] + A[-16 * c2 + c4 + -14 - 1][1]);
}
}
if (c0 >= (((3 * c1 + -1) * 2 < 0?-(-(3 * c1 + -1) / 2) : ((2 < 0?(-(3 * c1 + -1) + - 2 - 1) / - 2 : (3 * c1 + -1 + 2 - 1) / 2)))) && c1 <= (((((tsteps + -8) * 8 < 0?((8 < 0?-((-(tsteps + -8) + 8 + 1) / 8) : -((-(tsteps + -8) + 8 - 1) / 8))) : (tsteps + -8) / 8)) < c2?(((tsteps + -8) * 8 < 0?((8 < 0?-((-(tsteps + -8) + 8 + 1) / 8) : -((-(tsteps + -8) + 8 - 1) / 8))) : (tsteps + -8) / 8)) : c2))) {
for (c5 = (16 * c2 > 16 * c1 + 15?16 * c2 : 16 * c1 + 15); c5 <= ((16 * c2 + 15 < 16 * c1 + n + 12?16 * c2 + 15 : 16 * c1 + n + 12)); c5++) {
B[1][-16 * c1 + c5 + -14] = 0.2 * (A[1][-16 * c1 + c5 + -14] + A[1][-16 * c1 + c5 + -14 - 1] + A[1][1 + (-16 * c1 + c5 + -14)] + A[1 + 1][-16 * c1 + c5 + -14] + A[1 - 1][-16 * c1 + c5 + -14]);
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c5, c4, c2, c3)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB053-inneronly1-orig-no.c | #pragma omp parallel for | 100 | t main(int argc,char *argv[])
{
int i;
int j;
double a[20][20];
memset(a,0,(sizeof(a)));
<LOOP-START>for (i = 0; i < 20; i += 1) {
#pragma omp parallel for
for (j = 0; j < 20; j += 1) {
a[i][j] += i + j + 0.1;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB053-inneronly1-orig-no.c | #pragma omp parallel for | 100 | 20][20];
memset(a,0,(sizeof(a)));
#pragma omp parallel for
for (i = 0; i < 20; i += 1) {
<LOOP-START>for (j = 0; j < 20; j += 1) {
a[i][j] += i + j + 0.1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB053-inneronly1-orig-no.c | #pragma omp parallel for | 100 | j < 20; j += 1) {
a[i][j] += i + j + 0.1;
}
}
for (i = 0; i < 20 -1; i += 1) {
<LOOP-START>for (j = 0; j < 20; j += 1) {
a[i][j] += a[i + 1][j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB112-linear-orig-no.c | #pragma omp parallel for | 100 |
*/
#include <stdio.h>
int main()
{
int len=100;
double a[len], b[len], c[len];
int i,j=0;
<LOOP-START>for (i=0;i<len;i++)
{
a[i]=((double)i)/2.0;
b[i]=((double)i)/3.0;
c[i]=((double)i)/7.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB112-linear-orig-no.c | #pragma omp parallel for linear(j) | 100 | en;i++)
{
a[i]=((double)i)/2.0;
b[i]=((double)i)/3.0;
c[i]=((double)i)/7.0;
}
<LOOP-START>for (i=0;i<len;i++)
{
c[j]+=a[i]*b[i];
j++;
}<LOOP-END> <OMP-START>#pragma omp parallel for linear(j)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB109-orderedmissing-orig-yes.c | #pragma omp parallel for reduction(+:x) | 100 | * Missing the ordered clause
* Data race pair: x@56:5 vs. x@56:5
* */
int main()
{
int x =0;
<LOOP-START>for (int i = 0; i < 100; ++i) {
x++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:x)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB008-indirectaccess4-orig-yes.c | #pragma omp parallel for | 100 | e * xa1 = base;
double * xa2 = xa1 + 12;
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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB110-ordered-orig-no.c | #pragma omp parallel for reduction(+:x) | 100 | niv.
* Proper user of ordered directive and clause, no data races
* */
int main()
{
int x =0;
<LOOP-START>for (int i = 0; i < 100; ++i) {
x++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:x)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB101-task-value-orig-no.cpp | #pragma omp parallel for | 100 | #define MYLEN 100
int a[MYLEN];
void gen_task(int i)
{
a[i]= i+1;
}
int main()
{
int i=0;
<LOOP-START>for (i=0; i<MYLEN; i++)
{
gen_task(i);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB064-outeronly2-orig-no.c | #pragma omp parallel for private(i ,j ) | 100 | lelized so no race condition.
*/
int n=100, m=100;
double b[100][100];
int init()
{
int i,j,k;
<LOOP-START>for (i = 0; i < n; i++) {
#pragma omp parallel for private(j )
for (j = 0; j < m; j++) {
b[i][j] = i * j;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i ,j )<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB064-outeronly2-orig-no.c | #pragma omp parallel for private(j ) | 100 | int init()
{
int i,j,k;
#pragma omp parallel for private(i ,j )
for (i = 0; i < n; i++) {
<LOOP-START>for (j = 0; j < m; j++) {
b[i][j] = i * j;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j )<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB064-outeronly2-orig-no.c | #pragma omp parallel for private(i ,j ) | 100 | j < m; j++) {
b[i][j] = i * j;
}
}
return 0;
}
void foo(int n, int m)
{
int i,j;
<LOOP-START>for (i=0;i<n;i++)
for (j=1;j<m;j++) // Be careful about bounds of j
b[i][j]=b[i][j-1];
}
int print()
{
int i,j,k;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("%lf\n", b[i][j]);
}
}
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i ,j )<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB059-lastprivate-orig-no.c | #pragma omp parallel for lastprivate (x) | 100 | back to the shared one within the last iteration.
*/
#include <stdio.h>
void foo()
{
int i,x;
<LOOP-START>for (i=0;i<100;i++)
x=i;
printf("x=%d",x);
}
int main()
{
foo();
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for lastprivate (x)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c1, c4, c2, c3) | 100 | )
{
//int i;
//int j;
{
int c1;
int c3;
int c2;
int c4;
if (n >= 1) {
<LOOP-START>for (c1 = 0; c1 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c1++) {
#pragma omp parallel for private(c2, c4, c3)
for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for private(c3, c4)
for (c3 = 16 * c1; c3 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c2; c4 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c4++) {
X[c3][c4] = (((double )c3) * (c4 + 1) + 1) / n;
A[c3][c4] = (((double )c3) * (c4 + 2) + 2) / n;
B[c3][c4] = (((double )c3) * (c4 + 3) + 3) / n;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c4, c2, c3)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c2, c4, c3) | 100 | 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c1++) {
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for private(c3, c4)
for (c3 = 16 * c1; c3 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c2; c4 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c4++) {
X[c3][c4] = (((double )c3) * (c4 + 1) + 1) / n;
A[c3][c4] = (((double )c3) * (c4 + 2) + 2) / n;
B[c3][c4] = (((double )c3) * (c4 + 3) + 3) / n;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c4, c3)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c3, c4) | 100 | ?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
<LOOP-START>for (c3 = 16 * c1; c3 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c3++) {
#pragma omp parallel for private(c4)
for (c4 = 16 * c2; c4 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c4++) {
X[c3][c4] = (((double )c3) * (c4 + 1) + 1) / n;
A[c3][c4] = (((double )c3) * (c4 + 2) + 2) / n;
B[c3][c4] = (((double )c3) * (c4 + 3) + 3) / n;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c3, c4)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c4) | 100 | for (c3 = 16 * c1; c3 <= ((16 * c1 + 15 < n + -1?16 * c1 + 15 : n + -1)); c3++) {
<LOOP-START>for (c4 = 16 * c2; c4 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c4++) {
X[c3][c4] = (((double )c3) * (c4 + 1) + 1) / n;
A[c3][c4] = (((double )c3) * (c4 + 2) + 2) / n;
B[c3][c4] = (((double )c3) * (c4 + 3) + 3) / n;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c4)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c2, c15, c9, c8) | 100 | = 1 && tsteps >= 1) {
for (c0 = 0; c0 <= tsteps + -1; c0++) {
if (n >= 2) {
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
for (c8 = 0; c8 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c8++) {
for (c9 = (1 > 16 * c8?1 : 16 * c8); c9 <= ((16 * c8 + 15 < n + -1?16 * c8 + 15 : n + -1)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
B[c15][c9] = B[c15][c9] - A[c15][c9] * A[c15][c9] / B[c15][c9 - 1];
}
}
}
for (c8 = 0; c8 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c8++) {
for (c9 = (1 > 16 * c8?1 : 16 * c8); c9 <= ((16 * c8 + 15 < n + -1?16 * c8 + 15 : n + -1)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[c15][c9] = X[c15][c9] - X[c15][c9 - 1] * A[c15][c9] / B[c15][c9 - 1];
}
}
}
for (c8 = 0; c8 <= (((n + -3) * 16 < 0?((16 < 0?-((-(n + -3) + 16 + 1) / 16) : -((-(n + -3) + 16 - 1) / 16))) : (n + -3) / 16)); c8++) {
for (c9 = 16 * c8; c9 <= ((16 * c8 + 15 < n + -3?16 * c8 + 15 : n + -3)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[c15][n - c9 - 2] = (X[c15][n - 2 - c9] - X[c15][n - 2 - c9 - 1] * A[c15][n - c9 - 3]) / B[c15][n - 3 - c9];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c15, c9, c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c2, c15) | 100 | / B[c15][n - 3 - c9];
}
}
}
}
}
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[c15][n - 1] = X[c15][n - 1] / B[c15][n - 1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c15)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for | 100 | ?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
<LOOP-START>for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[c15][n - 1] = X[c15][n - 1] / B[c15][n - 1];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c2, c15, c9, c8) | 100 | [c15][n - 1] = X[c15][n - 1] / B[c15][n - 1];
}
}
if (n >= 2) {
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
for (c8 = 0; c8 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c8++) {
for (c9 = (1 > 16 * c8?1 : 16 * c8); c9 <= ((16 * c8 + 15 < n + -1?16 * c8 + 15 : n + -1)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
B[c9][c15] = B[c9][c15] - A[c9][c15] * A[c9][c15] / B[c9 - 1][c15];
}
}
}
for (c8 = 0; c8 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c8++) {
for (c9 = (1 > 16 * c8?1 : 16 * c8); c9 <= ((16 * c8 + 15 < n + -1?16 * c8 + 15 : n + -1)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[c9][c15] = X[c9][c15] - X[c9 - 1][c15] * A[c9][c15] / B[c9 - 1][c15];
}
}
}
for (c8 = 0; c8 <= (((n + -3) * 16 < 0?((16 < 0?-((-(n + -3) + 16 + 1) / 16) : -((-(n + -3) + 16 - 1) / 16))) : (n + -3) / 16)); c8++) {
for (c9 = 16 * c8; c9 <= ((16 * c8 + 15 < n + -3?16 * c8 + 15 : n + -3)); c9++) {
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[n - 2 - c9][c15] = (X[n - 2 - c9][c15] - X[n - c9 - 3][c15] * A[n - 3 - c9][c15]) / B[n - 2 - c9][c15];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c15, c9, c8)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for private(c2, c15) | 100 | / B[n - 2 - c9][c15];
}
}
}
}
}
<LOOP-START>for (c2 = 0; c2 <= (((n + -1) * 16 < 0?((16 < 0?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
#pragma omp parallel for
for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[n - 1][c15] = X[n - 1][c15] / B[n - 1][c15];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2, c15)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB044-adi-tile-no.c | #pragma omp parallel for | 100 | ?-((-(n + -1) + 16 + 1) / 16) : -((-(n + -1) + 16 - 1) / 16))) : (n + -1) / 16)); c2++) {
<LOOP-START>for (c15 = 16 * c2; c15 <= ((16 * c2 + 15 < n + -1?16 * c2 + 15 : n + -1)); c15++) {
X[n - 1][c15] = X[n - 1][c15] / B[n - 1][c15];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB067-restrictpointer1-orig-no.c | #pragma omp parallel for private (i) | 100 | double real8;
void foo(real8 * restrict newSxx, real8 * restrict newSyy, int length)
{
int i;
<LOOP-START>for (i = 0; i <= length - 1; i += 1) {
newSxx[i] = 0.0;
newSyy[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB024-simdtruedep-orig-yes.c | #pragma omp parallel for | 100 | clude <stdio.h>
int main(int argc, char* argv[])
{
int i;
int len=100;
int a[100], b[100];
<LOOP-START>for (i=0;i<len;i++)
{
a[i]=i;
b[i]=i+1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB091-threadprivate2-orig-no.c | #pragma omp parallel for reduction (+:sum1) | 100 | <len;i++)
{
sum0=sum0+i;
}
}
sum= sum+sum0;
/* reference calculation */
<LOOP-START>for (i=0;i<len;i++)
{
sum1=sum1+i;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction (+:sum1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB095-doall2-taskloop-orig-yes.c | #pragma omp parallel for | 100 | vs. Read_set is a data race pair.
*/
#include <stdio.h>
int a[100][100];
int main()
{
int i, j;
<LOOP-START>for (i = 0; i < 100; i++)
#pragma omp parallel for
for (j = 0; j < 100; j++)
{
a[i][j] = i + j;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB095-doall2-taskloop-orig-yes.c | #pragma omp parallel for | 100 | nt a[100][100];
int main()
{
int i, j;
#pragma omp parallel for
for (i = 0; i < 100; i++)
<LOOP-START>for (j = 0; j < 100; j++)
{
a[i][j] = i + j;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB018-plusplus-orig-yes.c | #pragma omp parallel for | 100 | nt input[1000];
int output[1000];
int main()
{
int i ;
int inLen=1000 ;
int outLen = 0;
<LOOP-START>for (i=0; i<inLen; ++i)
input[i]= i;
for (i=0; i<inLen; ++i)
{
output[outLen++] = input[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB097-target-teams-distribute-orig-no.c | #pragma omp parallel for | 100 | n = 2560;
double sum =0.0, sum2=0.0;
double a[len], b[len];
/*Initialize with some values*/
<LOOP-START>for (i=0; i<len; i++)
{
a[i]= ((double)i)/2.0;
b[i]= ((double)i)/3.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB084-threadprivatemissing-orig-yes.c | #pragma omp parallel for reduction(+:sum1) | 100 | =0;
for (i=1;i<=1000;i++)
{
foo (i);
}
sum= sum+sum0;
/* reference calculation */
<LOOP-START>for (i=1;i<=1000;i++)
{
sum1=sum1+i;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB049-fprintf-orig-no.c | #pragma omp parallel for | 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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB099-targetparallelfor2-orig-no.c | #pragma omp parallel for | 100 | map + array sections derived from pointers
*/
void foo (double* a, double* b, int N)
{
int i;
<LOOP-START>for (i=0;i< N ;i++)
b[i]=a[i]*(double)i;
}
int main(int argc, char* argv[])
{
int i;
int len = 1000;
double a[len], b[len];
#pragma omp parallel for
for (i=0; i<len; i++)
{
a[i]= ((double)i)/2.0;
b[i]=0.0;
}
foo(a, b, len);
printf("b[50]=%f\n",b[50]);
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB099-targetparallelfor2-orig-no.c | #pragma omp parallel for | 100 | ble)i;
}
int main(int argc, char* argv[])
{
int i;
int len = 1000;
double a[len], b[len];
<LOOP-START>for (i=0; i<len; i++)
{
a[i]= ((double)i)/2.0;
b[i]=0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB066-pointernoaliasing-orig-no.c | #pragma omp parallel for | 100 | * ) malloc (sizeof (double) * N );
double * m_nvol = (double* ) malloc (sizeof (double) * N );
<LOOP-START>for (int i=0; i < N; ++i )
{
m_pdv_sum[ i ] = 0.0;
m_nvol[ i ] = i*2.5;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB092-threadprivatemissing2-orig-yes.c | #pragma omp parallel for reduction(+:sum1) | 100 | =1000;i++)
{
sum0=sum0+i;
}
}
sum= sum+sum0;
/* reference calculation */
<LOOP-START>for (i=1;i<=1000;i++)
{
sum1=sum1+i;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum1)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB061-matrixvector1-orig-no.c | #pragma omp parallel for private(i ,j ) | 100 | l loop parallelization
*/
#define N 100
double a[N][N],v[N],v_out[N];
int init()
{
int i,j,k;
<LOOP-START>for (i = 0; i < N; i++) {
#pragma omp parallel for private(j )
for (j = 0; j < N; j++) {
a[i][j] = i * j + 0.01;
}
v_out[i] = i * j + 0.01;
v[i] = i * j + 0.01;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i ,j )<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB061-matrixvector1-orig-no.c | #pragma omp parallel for private(j ) | 100 | int init()
{
int i,j,k;
#pragma omp parallel for private(i ,j )
for (i = 0; i < N; i++) {
<LOOP-START>for (j = 0; j < N; j++) {
a[i][j] = i * j + 0.01;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j )<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB061-matrixvector1-orig-no.c | #pragma omp parallel for private (i,j) | 100 | t[i] = i * j + 0.01;
v[i] = i * j + 0.01;
}
return 0;
}
int mv()
{
int i,j;
<LOOP-START>for (i = 0; i < N; i++)
{
double sum = 0.0;
#pragma omp parallel for reduction(+:sum)
for (j = 0; j < N; j++)
{
sum += a[i][j]*v[j];
}
v_out[i] = sum;
}<LOOP-END> <OMP-START>#pragma omp parallel for private (i,j)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB061-matrixvector1-orig-no.c | #pragma omp parallel for reduction(+:sum) | 100 | gma omp parallel for private (i,j)
for (i = 0; i < N; i++)
{
double sum = 0.0;
<LOOP-START>for (j = 0; j < N; j++)
{
sum += a[i][j]*v[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB094-doall2-ordered-orig-no.c | #pragma omp parallel for | 100 | ed(n) is an OpenMP 4.5 addition.
*/
#include <stdio.h>
int a[100][100];
int main()
{
int i, j;
<LOOP-START>for (i = 0; i < 100; i++)
#pragma omp parallel for
for (j = 0; j < 100; j++)
{
a[i][j] = i + j;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB094-doall2-ordered-orig-no.c | #pragma omp parallel for | 100 | nt a[100][100];
int main()
{
int i, j;
#pragma omp parallel for
for (i = 0; i < 100; i++)
<LOOP-START>for (j = 0; j < 100; j++)
{
a[i][j] = i + j;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB055-jacobi2d-parallel-no.c | #pragma omp parallel for private(c1, c2) | 100 | ouble B[500 + 0][500 + 0])
{
//int i;
//int j;
{
int c2;
int c1;
if (n >= 1) {
<LOOP-START>for (c1 = 0; c1 <= n + -1; c1++) {
#pragma omp parallel for private(c2)
for (c2 = 0; c2 <= n + -1; c2++) {
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB055-jacobi2d-parallel-no.c | #pragma omp parallel for private(c2) | 100 | (n >= 1) {
#pragma omp parallel for private(c1, c2)
for (c1 = 0; c1 <= n + -1; c1++) {
<LOOP-START>for (c2 = 0; c2 <= n + -1; c2++) {
A[c1][c2] = (((double )c1) * (c2 + 2) + 2) / n;
B[c1][c2] = (((double )c1) * (c2 + 3) + 3) / n;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB055-jacobi2d-parallel-no.c | #pragma omp parallel for private(c1, c2) | 100 | [(-2 * c0 + 3 * c2 + 2) / 3] + A[1 - 1][(-2 * c0 + 3 * c2 + 2) / 3]);
}
}
}
<LOOP-START>for (c1 = ((((2 * c0 + 2) * 3 < 0?-(-(2 * c0 + 2) / 3) : ((3 < 0?(-(2 * c0 + 2) + - 3 - 1) / - 3 : (2 * c0 + 2 + 3 - 1) / 3)))) > c0 + -9?(((2 * c0 + 2) * 3 < 0?-(-(2 * c0 + 2) / 3) : ((3 < 0?(-(2 * c0 + 2) + - 3 - 1) / - 3 : (2 * c0 + 2 + 3 - 1) / 3)))) : c0 + -9); c1 <= (((((2 * c0 + 498) * 3 < 0?((3 < 0?-((-(2 * c0 + 498) + 3 + 1) / 3) : -((-(2 * c0 + 498) + 3 - 1) / 3))) : (2 * c0 + 498) / 3)) < c0?(((2 * c0 + 498) * 3 < 0?((3 < 0?-((-(2 * c0 + 498) + 3 + 1) / 3) : -((-(2 * c0 + 498) + 3 - 1) / 3))) : (2 * c0 + 498) / 3)) : c0)); c1++) {
B[-2 * c0 + 3 * c1][1] = 0.2 * (A[-2 * c0 + 3 * c1][1] + A[-2 * c0 + 3 * c1][1 - 1] + A[-2 * c0 + 3 * c1][1 + 1] + A[1 + (-2 * c0 + 3 * c1)][1] + A[-2 * c0 + 3 * c1 - 1][1]);
for (c2 = 2 * c0 + -2 * c1 + 2; c2 <= 2 * c0 + -2 * c1 + 498; c2++) {
A[-2 * c0 + 3 * c1 + -1][-2 * c0 + 2 * c1 + c2 + -1] = B[-2 * c0 + 3 * c1 + -1][-2 * c0 + 2 * c1 + c2 + -1];
B[-2 * c0 + 3 * c1][-2 * c0 + 2 * c1 + c2] = 0.2 * (A[-2 * c0 + 3 * c1][-2 * c0 + 2 * c1 + c2] + A[-2 * c0 + 3 * c1][-2 * c0 + 2 * c1 + c2 - 1] + A[-2 * c0 + 3 * c1][1 + (-2 * c0 + 2 * c1 + c2)] + A[1 + (-2 * c0 + 3 * c1)][-2 * c0 + 2 * c1 + c2] + A[-2 * c0 + 3 * c1 - 1][-2 * c0 + 2 * c1 + c2]);
}
A[-2 * c0 + 3 * c1 + -1][498] = B[-2 * c0 + 3 * c1 + -1][498];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c1, c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB055-jacobi2d-parallel-no.c | #pragma omp parallel for private(c2) | 100 | -2 * c0 + 3 * c1 + -1][498];
}
if (c0 >= 499) {
if ((2 * c0 + 1) % 3 == 0) {
<LOOP-START>for (c2 = ((2 * c0 + -992) * 3 < 0?-(-(2 * c0 + -992) / 3) : ((3 < 0?(-(2 * c0 + -992) + - 3 - 1) / - 3 : (2 * c0 + -992 + 3 - 1) / 3))); c2 <= (((2 * c0 + 499) * 3 < 0?((3 < 0?-((-(2 * c0 + 499) + 3 + 1) / 3) : -((-(2 * c0 + 499) + 3 - 1) / 3))) : (2 * c0 + 499) / 3)); c2++) {
A[498][(-2 * c0 + 3 * c2 + 995) / 3] = B[498][(-2 * c0 + 3 * c2 + 995) / 3];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB055-jacobi2d-parallel-no.c | #pragma omp parallel for private(c2) | 100 | 3 * c2 + 995) / 3] = B[498][(-2 * c0 + 3 * c2 + 995) / 3];
}
}
}
}
<LOOP-START>for (c2 = 20; c2 <= 517; c2++) {
A[498][c2 + -19] = B[498][c2 + -19];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(c2)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB065-pireduction-orig-no.c | #pragma omp parallel for reduction(+:pi) private(x) | 100 | le pi = 0.0;
long int i;
double x, interval_width;
interval_width = 1.0/(double)num_steps;
<LOOP-START>for (i = 0; i < num_steps; i++) {
x = (i+ 0.5) * interval_width;
pi += 1.0 / (x*x + 1.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:pi) private(x)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB020-privatemissing-var-yes.c | #pragma omp parallel for | 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 private(tmp)
for (i=0;i<len;i++)
{
tmp =a[i]+i;
a[i] = tmp;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB020-privatemissing-var-yes.c | #pragma omp parallel for private(tmp) | 100 | len = atoi(argv[1]);
int a[len];
#pragma omp parallel for
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 private(tmp)<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB006-indirectaccess2-orig-yes.c | #pragma omp parallel for | 100 | e * xa1 = base;
double * xa2 = xa1 + 12;
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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB050-functionparameter-orig-no.c | #pragma omp parallel for | 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<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB050-functionparameter-orig-no.c | #pragma omp parallel for | 100 | = 0.5 * c[i];
o1[i] = volnew_o8;
}
}
double o1[100];
double c[100];
int main()
{
int i;
<LOOP-START>for (i = 0; i < 100; ++i) {
c[i] = i + 1.01;
o1[i] = i + 1.01;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB098-simd2-orig-no.c | #pragma omp parallel for | 100 | vate.
*/
int main()
{
int len=100;
double a[len][len], b[len][len], c[len][len];
int i,j;
<LOOP-START>for (i=0;i<len;i++)
#pragma omp parallel for
for (j=0;j<len;j++)
{
a[i][j]=((double)i)/2.0;
b[i][j]=((double)i)/3.0;
c[i][j]=((double)i)/7.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB098-simd2-orig-no.c | #pragma omp parallel for | 100 | n][len], b[len][len], c[len][len];
int i,j;
#pragma omp parallel for
for (i=0;i<len;i++)
<LOOP-START>for (j=0;j<len;j++)
{
a[i][j]=((double)i)/2.0;
b[i][j]=((double)i)/3.0;
c[i][j]=((double)i)/7.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
LLNL/AutoParBench/benchmarks/reference_cpu_threading/dataracebench/DRB113-default-orig-no.c | #pragma omp parallel for private(i ,j ) | 100 | t(shared) to cover another option.
*/
int a[100][100];
int b[100][100];
int main()
{
int i,j;
<LOOP-START>for (i=0;i<100;i++) {
#pragma omp parallel for private(j )
for (j=0;j<100;j++) {
a[i][j] = i;
b[i][j] = i;
}
}<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.