filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
hypre-space/hypre/src/parcsr_ls/par_interp.c | #pragma omp parallel for private(i,j,jl,i1,i2,jj,jj1,ns,ne,size,rest,sum,diagonal,distribute,P_marker,P_marker_offd,strong_f_marker,jj_counter,jj_counter_offd,sgn,c_num,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE | 100 | -------------------------------------------------------------------*/
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (jl = 0; jl < num_threads; jl++)
{
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (jl < rest)
{
ns = jl * size + jl;
ne = (jl + 1) * size + jl + 1;
}
else
{
ns = jl * size + rest;
ne = (jl + 1) * size + rest;
}
jj_counter = 0;
if (jl > 0) { jj_counter = jj_count[jl - 1]; }
jj_counter_offd = 0;
if (jl > 0) { jj_counter_offd = jj_count_offd[jl - 1]; }
P_marker = hypre_CTAlloc(HYPRE_Int, n_fine, HYPRE_MEMORY_HOST);
if (num_cols_A_offd)
{
P_marker_offd = hypre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
}
else
{
P_marker_offd = NULL;
}
for (i = 0; i < n_fine; i++)
{
P_marker[i] = -1;
}
for (i = 0; i < num_cols_A_offd; i++)
{
P_marker_offd[i] = -1;
}
strong_f_marker = -2;
for (i = ns; i < ne; i++)
{
/*--------------------------------------------------------------------
* If i is a c-point, interpolation is the identity.
*--------------------------------------------------------------------*/
if (CF_marker[i] >= 0)
{
P_diag_i[i] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i];
P_diag_data[jj_counter] = one;
jj_counter++;
}
/*--------------------------------------------------------------------
* If i is an F-point, build interpolation.
*--------------------------------------------------------------------*/
else
{
/* Diagonal part of P */
P_diag_i[i] = jj_counter;
jj_begin_row = jj_counter;
for (jj = S_diag_i[i]; jj < S_diag_i[i + 1]; jj++)
{
i1 = S_diag_j[jj];
/*--------------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_diag_j
* and initialize interpolation weight to zero.
*--------------------------------------------------------------*/
if (CF_marker[i1] >= 0)
{
P_marker[i1] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i1];
P_diag_data[jj_counter] = zero;
jj_counter++;
}
/*--------------------------------------------------------------
* If neighbor i1 is an F-point, mark it as a strong F-point
* whose connection needs to be distributed.
*--------------------------------------------------------------*/
else if (CF_marker[i1] != -3)
{
P_marker[i1] = strong_f_marker;
}
}
jj_end_row = jj_counter;
/* Off-Diagonal part of P */
P_offd_i[i] = jj_counter_offd;
jj_begin_row_offd = jj_counter_offd;
if (num_procs > 1)
{
for (jj = S_offd_i[i]; jj < S_offd_i[i + 1]; jj++)
{
i1 = S_offd_j[jj];
/*-----------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_offd_j
* and initialize interpolation weight to zero.
*-----------------------------------------------------------*/
if (CF_marker_offd[i1] >= 0)
{
P_marker_offd[i1] = jj_counter_offd;
/*P_offd_j[jj_counter_offd] = fine_to_coarse_offd[i1];*/
P_offd_j[jj_counter_offd] = i1;
P_offd_data[jj_counter_offd] = zero;
jj_counter_offd++;
}
/*-----------------------------------------------------------
* If neighbor i1 is an F-point, mark it as a strong F-point
* whose connection needs to be distributed.
*-----------------------------------------------------------*/
else if (CF_marker_offd[i1] != -3)
{
P_marker_offd[i1] = strong_f_marker;
}
}
}
jj_end_row_offd = jj_counter_offd;
diagonal = A_diag_data[A_diag_i[i]];
/* Loop over ith row of A. First, the diagonal part of A */
for (jj = A_diag_i[i] + 1; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
/*--------------------------------------------------------------
* Case 1: neighbor i1 is a C-point and strongly influences i,
* accumulate a_{i,i1} into the interpolation weight.
*--------------------------------------------------------------*/
if (P_marker[i1] >= jj_begin_row)
{
P_diag_data[P_marker[i1]] += A_diag_data[jj];
}
/*--------------------------------------------------------------
* Case 2: neighbor i1 is an F-point and strongly influences i,
* distribute a_{i,i1} to C-points that strongly infuence i.
* Note: currently no distribution to the diagonal in this case.
HERE, we only want to distribut to points of the SAME function type
*--------------------------------------------------------------*/
else if (P_marker[i1] == strong_f_marker)
{
sum = zero;
/*-----------------------------------------------------------
* Loop over row of A for point i1 and calculate the sum
* of the connections to c-points that strongly influence i.
*-----------------------------------------------------------*/
sgn = 1;
if (A_diag_data[A_diag_i[i1]] < 0) { sgn = -1; }
/* Diagonal block part of row i1 */
for (jj1 = A_diag_i[i1]; jj1 < A_diag_i[i1 + 1]; jj1++)
{
i2 = A_diag_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (P_marker[i2] >= jj_begin_row &&
(sgn * A_diag_data[jj1]) < 0 )
{
sum += A_diag_data[jj1];
}
}
}
/* Off-Diagonal block part of row i1 */
if (num_procs > 1)
{
for (jj1 = A_offd_i[i1]; jj1 < A_offd_i[i1 + 1]; jj1++)
{
i2 = A_offd_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (P_marker_offd[i2] >= jj_begin_row_offd
&& (sgn * A_offd_data[jj1]) < 0)
{
sum += A_offd_data[jj1];
}
}
}
}
if (sum != 0)
{
distribute = A_diag_data[jj] / sum;
/*-----------------------------------------------------------
* Loop over row of A for point i1 and do the distribution.
*-----------------------------------------------------------*/
/* Diagonal block part of row i1 */
for (jj1 = A_diag_i[i1]; jj1 < A_diag_i[i1 + 1]; jj1++)
{
i2 = A_diag_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (P_marker[i2] >= jj_begin_row
&& (sgn * A_diag_data[jj1]) < 0)
{
P_diag_data[P_marker[i2]]
+= distribute * A_diag_data[jj1];
}
}
}
/* Off-Diagonal block part of row i1 */
if (num_procs > 1)
{
for (jj1 = A_offd_i[i1]; jj1 < A_offd_i[i1 + 1]; jj1++)
{
i2 = A_offd_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (P_marker_offd[i2] >= jj_begin_row_offd
&& (sgn * A_offd_data[jj1]) < 0)
{
P_offd_data[P_marker_offd[i2]]
+= distribute * A_offd_data[jj1];
}
}
}
}
}
else /* sum = 0 - only add to diag if the same function type */
{
if (num_functions == 1 || dof_func[i] == dof_func[i1])
{
diagonal += A_diag_data[jj];
}
}
}
/*--------------------------------------------------------------
* Case 3: neighbor i1 weakly influences i, accumulate a_{i,i1}
* into the diagonal. (only if the same function type)
*--------------------------------------------------------------*/
else if (CF_marker[i1] != -3)
{
if (num_functions == 1 || dof_func[i] == dof_func[i1])
{
diagonal += A_diag_data[jj];
}
}
}
/*----------------------------------------------------------------
* Still looping over ith row of A. Next, loop over the
* off-diagonal part of A
*---------------------------------------------------------------*/
if (num_procs > 1)
{
for (jj = A_offd_i[i]; jj < A_offd_i[i + 1]; jj++)
{
i1 = A_offd_j[jj];
/*--------------------------------------------------------------
* Case 1: neighbor i1 is a C-point and strongly influences i,
* accumulate a_{i,i1} into the interpolation weight.
*--------------------------------------------------------------*/
if (P_marker_offd[i1] >= jj_begin_row_offd)
{
P_offd_data[P_marker_offd[i1]] += A_offd_data[jj];
}
/*------------------------------------------------------------
* Case 2: neighbor i1 is an F-point and strongly influences i,
* distribute a_{i,i1} to C-points that strongly infuence i.
* Note: currently no distribution to the diagonal in this case.
AGAIN, we only want to distribut to points of the SAME function type
*-----------------------------------------------------------*/
else if (P_marker_offd[i1] == strong_f_marker)
{
sum = zero;
/*---------------------------------------------------------
* Loop over row of A_ext for point i1 and calculate the sum
* of the connections to c-points that strongly influence i.
*---------------------------------------------------------*/
/* find row number */
c_num = A_offd_j[jj];
sgn = 1;
if (A_ext_data[A_ext_i[c_num]] < 0) { sgn = -1; }
for (jj1 = A_ext_i[c_num]; jj1 < A_ext_i[c_num + 1]; jj1++)
{
i2 = (HYPRE_Int)A_ext_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (i2 > -1)
{
/* in the diagonal block */
if (P_marker[i2] >= jj_begin_row
&& (sgn * A_ext_data[jj1]) < 0)
{
sum += A_ext_data[jj1];
}
}
else
{
/* in the off_diagonal block */
if (P_marker_offd[-i2 - 1] >= jj_begin_row_offd
&& (sgn * A_ext_data[jj1]) < 0)
{
sum += A_ext_data[jj1];
}
}
}
}
if (sum != 0)
{
distribute = A_offd_data[jj] / sum;
/*---------------------------------------------------------
* Loop over row of A_ext for point i1 and do
* the distribution.
*--------------------------------------------------------*/
/* Diagonal block part of row i1 */
for (jj1 = A_ext_i[c_num]; jj1 < A_ext_i[c_num + 1]; jj1++)
{
i2 = (HYPRE_Int)A_ext_j[jj1];
if (num_functions == 1 || dof_func[i1] == dof_func[i2])
{
if (i2 > -1) /* in the diagonal block */
{
if (P_marker[i2] >= jj_begin_row
&& (sgn * A_ext_data[jj1]) < 0)
{
P_diag_data[P_marker[i2]]
+= distribute * A_ext_data[jj1];
}
}
else
{
/* in the off_diagonal block */
if (P_marker_offd[-i2 - 1] >= jj_begin_row_offd
&& (sgn * A_ext_data[jj1]) < 0)
P_offd_data[P_marker_offd[-i2 - 1]]
+= distribute * A_ext_data[jj1];
}
}
}
}
else /* sum = 0 */
{
if (num_functions == 1 || dof_func[i] == dof_func_offd[i1])
{
diagonal += A_offd_data[jj];
}
}
}
/*-----------------------------------------------------------
* Case 3: neighbor i1 weakly influences i, accumulate a_{i,i1}
* into the diagonal.
*-----------------------------------------------------------*/
else if (CF_marker_offd[i1] != -3)
{
if (num_functions == 1 || dof_func[i] == dof_func_offd[i1])
{
diagonal += A_offd_data[jj];
}
}
}
}
/*-----------------------------------------------------------------
* Set interpolation weight by dividing by the diagonal.
*-----------------------------------------------------------------*/
if (diagonal == 0.0)
{
if (print_level)
{
hypre_printf(" Warning! zero diagonal! Proc id %d row %d\n", my_id, i);
}
for (jj = jj_begin_row; jj < jj_end_row; jj++)
{
P_diag_data[jj] = 0.0;
}
for (jj = jj_begin_row_offd; jj < jj_end_row_offd; jj++)
{
P_offd_data[jj] = 0.0;
}
}
else
{
for (jj = jj_begin_row; jj < jj_end_row; jj++)
{
P_diag_data[jj] /= -diagonal;
}
for (jj = jj_begin_row_offd; jj < jj_end_row_offd; jj++)
{
P_offd_data[jj] /= -diagonal;
}
}
}
strong_f_marker--;
P_offd_i[i + 1] = jj_counter_offd;
}
hypre_TFree(P_marker, HYPRE_MEMORY_HOST);
hypre_TFree(P_marker_offd, HYPRE_MEMORY_HOST);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jl,i1,i2,jj,jj1,ns,ne,size,rest,sum,diagonal,distribute,P_marker,P_marker_offd,strong_f_marker,jj_counter,jj_counter_offd,sgn,c_num,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | r = hypre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols_A_offd; i++)
{
P_marker[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ex] == 0) { index++; }
tmp_map_offd[i] = index++;
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < P_offd_size; i++)
P_offd_j[i] = hypre_BinarySearch(tmp_map_offd,
P_offd_j[i],
num_cols_P_offd);
hypre_TFree(P_marker, HYPRE_MEMORY_HOST);
}
for (i = 0; i < n_fine; i++)
if (CF_marker[i] == -3) { CF_marker[i] = -1; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_ilu_setup.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | perm = perm;
h_rqperm = rqperm;
}
/* Fill data */
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < n; i++)
{
P_diag_i[i] = i;
P_diag_j[i] = h_perm[i];
P_diag_data[i] = 1.0;
Q_diag_i[i] = i;
Q_diag_j[i] = h_rqperm[i];
Q_diag_data[i] = 1.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | o_coarse = hypre_CTAlloc(HYPRE_Int, n_fine, HYPRE_MEMORY_HOST);
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < n_fine; i++) { fine_to_coarse[i] = -1; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,i1,jj,ns,ne,size,rest) HYPRE_SMP_SCHEDULE | 100 | --------*/
/* RDF: this looks a little tricky, but doable */
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (j = 0; j < num_threads; j++)
{
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (j < rest)
{
ns = j * size + j;
ne = (j + 1) * size + j + 1;
}
else
{
ns = j * size + rest;
ne = (j + 1) * size + rest;
}
for (i = ns; i < ne; i++)
{
/*--------------------------------------------------------------------
* If i is a C-point, interpolation is the identity. Also set up
* mapping vector.
*--------------------------------------------------------------------*/
if (CF_marker[i] >= 0)
{
jj_count[j]++;
fine_to_coarse[i] = coarse_counter[j];
coarse_counter[j]++;
}
/*--------------------------------------------------------------------
* If i is an F-point, interpolation is the approximation of A_{ff}^{-1}A_{fc}
*--------------------------------------------------------------------*/
else
{
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
if ((CF_marker[i1] >= 0) && (method > 0))
{
jj_count[j]++;
}
}
if (num_procs > 1)
{
for (jj = A_offd_i[i]; jj < A_offd_i[i + 1]; jj++)
{
i1 = A_offd_j[jj];
if ((CF_marker_offd[i1] >= 0) && (method > 0))
{
jj_count_offd[j]++;
}
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,i1,jj,ns,ne,size,rest) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,ns,ne,size,rest,coarse_shift) HYPRE_SMP_SCHEDULE | 100 | ypre_CTAlloc(HYPRE_BigInt, num_cols_A_offd, HYPRE_MEMORY_HOST);
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (j = 0; j < num_threads; j++)
{
coarse_shift = 0;
if (j > 0) { coarse_shift = coarse_counter[j - 1]; }
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (j < rest)
{
ns = j * size + j;
ne = (j + 1) * size + j + 1;
}
else
{
ns = j * size + rest;
ne = (j + 1) * size + rest;
}
for (i = ns; i < ne; i++)
{
fine_to_coarse[i] += coarse_shift;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,ns,ne,size,rest,coarse_shift) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | f (debug_flag == 4) { wall_time = time_getWallclockSeconds(); }
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>//for (i = 0; i < n_fine; i++) fine_to_coarse[i] -= my_first_cpt;
/*-----------------------------------------------------------------------
* Loop over fine grid points.
*-----------------------------------------------------------------------*/
a_diag = hypre_CTAlloc(HYPRE_Real, n_fine, HYPRE_MEMORY_HOST);
for (i = 0; i < n_fine; i++)
{
if (CF_marker[i] < 0)
{
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
if ( i == i1 ) /* diagonal of A only */
{
a_diag[i] = 1.0 / A_diag_data[jj];
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,jl,i1,jj,ns,ne,size,rest,P_marker,P_marker_offd,jj_counter,jj_counter_offd,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE | 100 | = 1.0 / A_diag_data[jj];
}
}
}
}
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (jl = 0; jl < num_threads; jl++)
{
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (jl < rest)
{
ns = jl * size + jl;
ne = (jl + 1) * size + jl + 1;
}
else
{
ns = jl * size + rest;
ne = (jl + 1) * size + rest;
}
jj_counter = 0;
if (jl > 0) { jj_counter = jj_count[jl - 1]; }
jj_counter_offd = 0;
if (jl > 0) { jj_counter_offd = jj_count_offd[jl - 1]; }
P_marker = hypre_CTAlloc(HYPRE_Int, n_fine, HYPRE_MEMORY_HOST);
if (num_cols_A_offd)
{
P_marker_offd = hypre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
}
else
{
P_marker_offd = NULL;
}
for (i = 0; i < n_fine; i++)
{
P_marker[i] = -1;
}
for (i = 0; i < num_cols_A_offd; i++)
{
P_marker_offd[i] = -1;
}
for (i = ns; i < ne; i++)
{
/*--------------------------------------------------------------------
* If i is a c-point, interpolation is the identity.
*--------------------------------------------------------------------*/
if (CF_marker[i] >= 0)
{
P_diag_i[i] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i];
P_diag_data[jj_counter] = one;
jj_counter++;
}
/*--------------------------------------------------------------------
* If i is an F-point, build interpolation.
*--------------------------------------------------------------------*/
else
{
/* Diagonal part of P */
P_diag_i[i] = jj_counter;
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
/*--------------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_diag_j
* and initialize interpolation weight to zero.
*--------------------------------------------------------------*/
if ((CF_marker[i1] >= 0) && (method > 0))
{
P_marker[i1] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i1];
/*
if(method == 0)
{
P_diag_data[jj_counter] = 0.0;
}
*/
if (method == 1)
{
P_diag_data[jj_counter] = - A_diag_data[jj];
}
else if (method == 2)
{
P_diag_data[jj_counter] = - A_diag_data[jj] * a_diag[i];
}
jj_counter++;
}
}
/* Off-Diagonal part of P */
P_offd_i[i] = jj_counter_offd;
if (num_procs > 1)
{
for (jj = A_offd_i[i]; jj < A_offd_i[i + 1]; jj++)
{
i1 = A_offd_j[jj];
/*-----------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_offd_j
* and initialize interpolation weight to zero.
*-----------------------------------------------------------*/
if ((CF_marker_offd[i1] >= 0) && (method > 0))
{
P_marker_offd[i1] = jj_counter_offd;
/*P_offd_j[jj_counter_offd] = fine_to_coarse_offd[i1];*/
P_offd_j[jj_counter_offd] = i1;
/*
if(method == 0)
{
P_offd_data[jj_counter_offd] = 0.0;
}
*/
if (method == 1)
{
P_offd_data[jj_counter_offd] = - A_offd_data[jj];
}
else if (method == 2)
{
P_offd_data[jj_counter_offd] = - A_offd_data[jj] * a_diag[i];
}
jj_counter_offd++;
}
}
}
}
P_offd_i[i + 1] = jj_counter_offd;
}
hypre_TFree(P_marker, HYPRE_MEMORY_HOST);
hypre_TFree(P_marker_offd, HYPRE_MEMORY_HOST);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jl,i1,jj,ns,ne,size,rest,P_marker,P_marker_offd,jj_counter,jj_counter_offd,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ypre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols_A_offd; i++)
{
P_marker[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 0) { index++; }
tmp_map_offd[i] = index++;
}
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < P_offd_size; i++)
P_offd_j[i] = hypre_BinarySearch(tmp_map_offd,
P_offd_j[i],
num_cols_P_offd);
hypre_TFree(P_marker, HYPRE_MEMORY_HOST);
}
for (i = 0; i < n_fine; i++)
if (CF_marker[i] == -3) { CF_marker[i] = -1; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | o_coarse = hypre_CTAlloc(HYPRE_Int, n_fine, HYPRE_MEMORY_HOST);
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < n_fine; i++) { fine_to_coarse[i] = -1; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,i1,jj,ns,ne,size,rest) HYPRE_SMP_SCHEDULE | 100 | --------*/
/* RDF: this looks a little tricky, but doable */
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (j = 0; j < num_threads; j++)
{
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (j < rest)
{
ns = j * size + j;
ne = (j + 1) * size + j + 1;
}
else
{
ns = j * size + rest;
ne = (j + 1) * size + rest;
}
for (i = ns; i < ne; i++)
{
/*--------------------------------------------------------------------
* If i is a C-point, interpolation is the identity. Also set up
* mapping vector.
*--------------------------------------------------------------------*/
if (CF_marker[i] >= 0)
{
jj_count[j]++;
fine_to_coarse[i] = coarse_counter[j];
coarse_counter[j]++;
}
/*--------------------------------------------------------------------
* If i is an F-point, interpolation is the approximation of A_{ff}^{-1}A_{fc}
*--------------------------------------------------------------------*/
else
{
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
if (CF_marker[i1] >= 0)
{
jj_count[j]++;
}
}
if (num_procs > 1)
{
for (jj = A_offd_i[i]; jj < A_offd_i[i + 1]; jj++)
{
i1 = A_offd_j[jj];
if (CF_marker_offd[i1] >= 0)
{
jj_count_offd[j]++;
}
}
}
}
/*--------------------------------------------------------------------
* Set up the indexes for the DRS method
*--------------------------------------------------------------------*/
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,i1,jj,ns,ne,size,rest) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,ns,ne,size,rest,coarse_shift) HYPRE_SMP_SCHEDULE | 100 | f (debug_flag == 4) { wall_time = time_getWallclockSeconds(); }
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (j = 0; j < num_threads; j++)
{
coarse_shift = 0;
if (j > 0) { coarse_shift = coarse_counter[j - 1]; }
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (j < rest)
{
ns = j * size + j;
ne = (j + 1) * size + j + 1;
}
else
{
ns = j * size + rest;
ne = (j + 1) * size + rest;
}
for (i = ns; i < ne; i++)
{
fine_to_coarse[i] += coarse_shift;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,ns,ne,size,rest,coarse_shift) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | f (debug_flag == 4) { wall_time = time_getWallclockSeconds(); }
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>//for (i = 0; i < n_fine; i++) fine_to_coarse[i] -= my_first_cpt;
/*-----------------------------------------------------------------------
* Loop over fine grid points.
*-----------------------------------------------------------------------*/
a_diag = hypre_CTAlloc(HYPRE_Real, n_fine, HYPRE_MEMORY_HOST);
for (i = 0; i < n_fine; i++)
{
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
if ( i == i1 ) /* diagonal of A only */
{
a_diag[i] = 1.0 / A_diag_data[jj];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i,j,jl,i1,jj,ns,ne,size,rest,P_marker,P_marker_offd,jj_counter,jj_counter_offd,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE | 100 | a_diag[i] = 1.0 / A_diag_data[jj];
}
}
}
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (jl = 0; jl < num_threads; jl++)
{
size = n_fine / num_threads;
rest = n_fine - size * num_threads;
if (jl < rest)
{
ns = jl * size + jl;
ne = (jl + 1) * size + jl + 1;
}
else
{
ns = jl * size + rest;
ne = (jl + 1) * size + rest;
}
jj_counter = 0;
if (jl > 0) { jj_counter = jj_count[jl - 1]; }
jj_counter_offd = 0;
if (jl > 0) { jj_counter_offd = jj_count_offd[jl - 1]; }
P_marker = hypre_CTAlloc(HYPRE_Int, n_fine, HYPRE_MEMORY_HOST);
if (num_cols_A_offd)
{
P_marker_offd = hypre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
}
else
{
P_marker_offd = NULL;
}
for (i = 0; i < n_fine; i++)
{
P_marker[i] = -1;
}
for (i = 0; i < num_cols_A_offd; i++)
{
P_marker_offd[i] = -1;
}
for (i = ns; i < ne; i++)
{
/*--------------------------------------------------------------------
* If i is a c-point, interpolation is the identity.
*--------------------------------------------------------------------*/
if (CF_marker[i] >= 0)
{
P_diag_i[i] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i];
P_diag_data[jj_counter] = one;
jj_counter++;
}
/*--------------------------------------------------------------------
* If i is an F-point, build interpolation.
*--------------------------------------------------------------------*/
else
{
/* Diagonal part of P */
P_diag_i[i] = jj_counter;
for (jj = A_diag_i[i]; jj < A_diag_i[i + 1]; jj++)
{
i1 = A_diag_j[jj];
/*--------------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_diag_j
* and initialize interpolation weight to zero.
*--------------------------------------------------------------*/
if (CF_marker[i1] >= 0)
{
P_marker[i1] = jj_counter;
P_diag_j[jj_counter] = fine_to_coarse[i1];
P_diag_data[jj_counter] = - A_diag_data[jj] * a_diag[i];
jj_counter++;
}
}
/* Off-Diagonal part of P */
P_offd_i[i] = jj_counter_offd;
if (num_procs > 1)
{
for (jj = A_offd_i[i]; jj < A_offd_i[i + 1]; jj++)
{
i1 = A_offd_j[jj];
/*-----------------------------------------------------------
* If neighbor i1 is a C-point, set column number in P_offd_j
* and initialize interpolation weight to zero.
*-----------------------------------------------------------*/
if (CF_marker_offd[i1] >= 0)
{
P_marker_offd[i1] = jj_counter_offd;
P_offd_j[jj_counter_offd] = i1;
P_offd_data[jj_counter_offd] = - A_offd_data[jj] * a_diag[i];
jj_counter_offd++;
}
}
}
}
P_offd_i[i + 1] = jj_counter_offd;
}
hypre_TFree(P_marker, HYPRE_MEMORY_HOST);
hypre_TFree(P_marker_offd, HYPRE_MEMORY_HOST);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jl,i1,jj,ns,ne,size,rest,P_marker,P_marker_offd,jj_counter,jj_counter_offd,jj_begin_row,jj_end_row,jj_begin_row_offd,jj_end_row_offd) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | pre_CTAlloc(HYPRE_Int, num_cols_A_offd, HYPRE_MEMORY_HOST);
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_cols_A_offd; i++)
{
P_marker[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/parcsr_ls/par_mgr_interp.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 0) { index++; }
tmp_map_offd[i] = index++;
}
#if 0
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < P_offd_size; i++)
{
P_offd_j[i] = hypre_BinarySearch(tmp_map_offd,
P_offd_j[i],
num_cols_P_offd);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/hopscotch_hash.c | #pragma omp parallel for | 100 | h = hypre_TAlloc(HYPRE_Int, num_buckets, HYPRE_MEMORY_HOST);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < num_buckets; ++i)
{
s->hopInfo[i] = 0;
s->hash[i] = HYPRE_HOPSCOTCH_HASH_EMPTY;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hypre-space/hypre/src/utilities/hopscotch_hash.c | #pragma omp parallel for | 100 | hypre_TAlloc(HYPRE_BigInt, num_buckets, HYPRE_MEMORY_HOST);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < num_buckets; ++i)
{
s->hopInfo[i] = 0;
s->hash[i] = HYPRE_HOPSCOTCH_HASH_EMPTY;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hypre-space/hypre/src/utilities/hopscotch_hash.c | #pragma omp parallel for | 100 | lloc(hypre_HopscotchBucket, num_buckets, HYPRE_MEMORY_HOST);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < num_buckets; i++)
{
InitBucket(&m->table[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hypre-space/hypre/src/utilities/hopscotch_hash.c | #pragma omp parallel for | 100 | c(hypre_BigHopscotchBucket, num_buckets, HYPRE_MEMORY_HOST);
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < num_buckets; i++)
{
InitBigBucket(&m->table[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hypre-space/hypre/src/utilities/int_array.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | HYPRE_Int size = hypre_IntArraySize(v);
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
array_data[i] = value;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/int_array.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | HYPRE_Int size = hypre_IntArraySize(v);
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
array_data[i] = i % cycle;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/int_array.c | #pragma omp parallel for private(i) reduction(+:num_values) HYPRE_SMP_SCHEDULE | 100 | _Int num_values = 0;
HYPRE_Int i;
#if !defined(_MSC_VER) && defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
num_values += (array_data[i] == value) ? 1 : 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+:num_values) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/int_array.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | HYPRE_Int *w_data = hypre_IntArrayData(w);
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
w_data[v_data[i]] = i;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/int_array.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | hypre_IntArrayNegateDevice(v);
}
else
#endif
{
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
array_data[i] = - array_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/merge_sort.c | #pragma omp parallel for HYPRE_SMP_SCHEDULE | 100 | nverse_map, 2 * len, 16 * hypre_NumThreads());
HYPRE_Int i;
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < len; i++)
{
HYPRE_Int old = hypre_UnorderedIntMapPutIfAbsent(inverse_map, (*out)[i], i);
hypre_assert(old == HYPRE_HOPSCOTCH_HASH_EMPTY);
#ifdef DBG_MERGE_SORT
if (hypre_UnorderedIntMapGet(inverse_map, (*out)[i]) != i)
{
fprintf(stderr, "%d %d\n", i, (*out)[i]);
hypre_assert(false);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/utilities/merge_sort.c | #pragma omp parallel for HYPRE_SMP_SCHEDULE | 100 | nverse_map, 2 * len, 16 * hypre_NumThreads());
HYPRE_Int i;
#ifdef HYPRE_CONCURRENT_HOPSCOTCH
<LOOP-START>for (i = 0; i < len; i++)
{
HYPRE_Int old = hypre_UnorderedBigIntMapPutIfAbsent(inverse_map, (*out)[i], i);
hypre_assert(old == HYPRE_HOPSCOTCH_HASH_EMPTY);
#ifdef DBG_MERGE_SORT
if (hypre_UnorderedBigIntMapGet(inverse_map, (*out)[i]) != i)
{
fprintf(stderr, "%d %d\n", i, (*out)[i]);
hypre_assert(false);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/sstruct_ls/maxwell_zeroBC.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ectorData(v);
HYPRE_Int i;
HYPRE_Int ierr = 0;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < nrows; i++)
{
vector_data[rows[i]] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i, ii, j) HYPRE_SMP_SCHEDULE | 100 | square */
if (num_rows_A != num_cols_A)
{
return -1;
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < nnzrows_A; i++)
{
ii = rownnz_A ? rownnz_A[i] : i;
for (j = A_i[ii]; j < A_i[ii + 1]; j++)
{
if (A_j[j] == ii)
{
if (j != A_i[ii])
{
hypre_swap(A_j, A_i[ii], j);
hypre_swap_c(A_data, A_i[ii], j);
}
break;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, ii, j) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE | 100 | num_nonzeros = hypre_CSRMatrixNumNonzeros(A);
HYPRE_Int i;
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_nonzeros; i++)
{
sum += data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE | 100 | YPRE_Complex sum = 0;
hypre_assert(num_nonzeros == A_i[nrows]);
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_nonzeros; ++i)
{
HYPRE_Complex v = A_data[i];
sum += v * v;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i, j, sl, sr) HYPRE_SMP_SCHEDULE | 100 | PRE_Complex sl;
HYPRE_Complex sr;
if (ldata && rdata)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < nrows; i++)
{
sl = ldata[i];
for (j = A_i[i]; j < A_i[i + 1]; j++)
{
sr = rdata[A_j[j]];
A_data[j] = sl * A_data[j] * sr;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j, sl, sr) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i, j, sl) HYPRE_SMP_SCHEDULE | 100 | [j] * sr;
}
}
}
else if (ldata && !rdata)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < nrows; i++)
{
sl = ldata[i];
for (j = A_i[i]; j < A_i[i + 1]; j++)
{
A_data[j] = sl * A_data[j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j, sl) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matop.c | #pragma omp parallel for private(i, j, sr) HYPRE_SMP_SCHEDULE | 100 | _data[j];
}
}
}
else if (!ldata && rdata)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < nrows; i++)
{
for (j = A_i[i]; j < A_i[i + 1]; j++)
{
sr = rdata[A_j[j]];
A_data[j] = A_data[j] * sr;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j, sr) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | Int total_size = size * num_vectors;
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < total_size; i++)
{
vector_data[i] = value;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ce(x, istride, ostride, size, data);
}
else
#endif
{
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i += istride)
{
x_data[(i / istride) * ostride] = data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | Int total_size = size * num_vectors;
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < total_size; i++)
{
y_data[i] *= alpha;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | Int total_size = size * num_vectors;
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < total_size; i++)
{
y_data[i] += alpha * x_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | Int total_size = size * num_vectors;
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < total_size; i++)
{
z_data[i] = alpha * x_data[i] + beta * y_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | num_vectors_y == 1)
{
if (marker)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
if (marker[i] == marker_val)
{
y_data[i] += x_data[i] / b_data[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
}
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += x_data[i] / b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | num_vectors_y == 2)
{
if (marker)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
val = 1.0 / b_data[i];
if (marker[i] == marker_val)
{
y_data[i] += x_data[i] * val;
y_data[i + size] += x_data[i + size] * val;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
}
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
val = 1.0 / b_data[i];
y_data[i] += x_data[i] * val;
y_data[i + size] += x_data[i + size] * val;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i, j) HYPRE_SMP_SCHEDULE | 100 | s_x == num_vectors_y)
{
if (marker)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
val = 1.0 / b_data[i];
if (marker[i] == marker_val)
{
for (j = 0; j < num_vectors_x; j++)
{
y_data[i + size * j] += x_data[i + size * j] * val;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i, j) HYPRE_SMP_SCHEDULE | 100 | }
}
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < size; i++)
{
val = 1.0 / b_data[i];
for (j = 0; j < num_vectors_x; j++)
{
y_data[i + size * j] += x_data[i + size * j] * val;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) reduction(+:result) HYPRE_SMP_SCHEDULE | 100 | ors;
HYPRE_Real result = 0.0;
HYPRE_Int i;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < total_size; i++)
{
result += hypre_conj(y_data[i]) * x_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+:result) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE | 100 | ze * num_vectors;
HYPRE_Complex sum = 0;
HYPRE_Int i;
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < total_size; i++)
{
sum += data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+:sum) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | stribute parallel for private(i) is_device_ptr(y_data, x_data)
#elif defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += hypre_max(alpha * x_data[i], beta * y_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/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 * num_vectors; i++)
{
y_data[i] = beta * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ------------------------------*/
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows * num_vectors; i++)
{
y_data[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | i] = 0.0;
}
}
else if (temp == 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>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> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | data[i];
}
}
else if (temp == -1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>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> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | y_data[i] = -b_data[i];
}
}
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows * num_vectors; i++)
{
y_data[i] = temp * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE | 100 | switch (num_vectors)
{
case 2:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
HYPRE_Complex tmp[2] = {0.0, 0.0};
for (jj = A_i[m]; jj < A_i[m + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
}
HYPRE_Int yidx = m * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE | 100 | }
break;
case 3:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
HYPRE_Complex tmp[3] = {0.0, 0.0, 0.0};
for (jj = A_i[m]; jj < A_i[m + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
tmp[2] += coef * x_data[xidx + 2 * vecstride_x];
}
HYPRE_Int yidx = m * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
y_data[yidx + 2 * vecstride_y] += tmp[2];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE | 100 | }
break;
case 4:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
HYPRE_Complex tmp[4] = {0.0, 0.0, 0.0, 0.0};
for (jj = A_i[m]; jj < A_i[m + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
tmp[2] += coef * x_data[xidx + 2 * vecstride_x];
tmp[3] += coef * x_data[xidx + 3 * vecstride_x];
}
HYPRE_Int yidx = m * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
y_data[yidx + 2 * vecstride_y] += tmp[2];
y_data[yidx + 3 * vecstride_y] += tmp[3];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj,m) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,m,tempx) HYPRE_SMP_SCHEDULE | 100 | }
break;
default:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
for (j = 0; j < num_vectors; j++)
{
tempx = 0.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> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE | 100 | switch (num_vectors)
{
case 2:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
HYPRE_Complex tmp[2] = {0.0, 0.0};
for (jj = A_i[i]; jj < A_i[i + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
}
HYPRE_Int yidx = i * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE | 100 | }
break;
case 3:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
HYPRE_Complex tmp[3] = {0.0, 0.0, 0.0};
for (jj = A_i[i]; jj < A_i[i + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
tmp[2] += coef * x_data[xidx + 2 * vecstride_x];
}
HYPRE_Int yidx = i * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
y_data[yidx + 2 * vecstride_y] += tmp[2];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE | 100 | }
break;
case 4:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
HYPRE_Complex tmp[4] = {0.0, 0.0, 0.0, 0.0};
for (jj = A_i[i]; jj < A_i[i + 1]; jj++)
{
HYPRE_Int xidx = A_j[jj] * idxstride_x;
HYPRE_Complex coef = A_data[jj];
tmp[0] += coef * x_data[xidx];
tmp[1] += coef * x_data[xidx + vecstride_x];
tmp[2] += coef * x_data[xidx + 2 * vecstride_x];
tmp[3] += coef * x_data[xidx + 3 * vecstride_x];
}
HYPRE_Int yidx = i * idxstride_y;
y_data[yidx] += tmp[0];
y_data[yidx + vecstride_y] += tmp[1];
y_data[yidx + 2 * vecstride_y] += tmp[2];
y_data[yidx + 3 * vecstride_y] += tmp[3];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,jj) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,jj,tempx) HYPRE_SMP_SCHEDULE | 100 | }
break;
default:
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
for (j = 0; j < num_vectors; ++j)
{
tempx = 0.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> |
hypre-space/hypre/src/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;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | is smaller than xpar*num_rows */
if (temp == 0.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | a[i] = 0.0;
}
if (alpha == 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] = tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | } // y = A*x
else if (alpha == -1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx -= A_data[j] * x_data[A_j[j]];
}
y_data[m] = tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | }
} // y = -A*x
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] = alpha * tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | beta == -alpha
{
if (alpha == 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = -b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = -b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | } // y = A*x - b
else if (alpha == -1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] -= tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
} // y = -A*x + b
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = -alpha * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | y_data[i] = -alpha * b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += alpha * tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | / beta == alpha
{
if (alpha == 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | } // y = A*x + b
else if (alpha == -1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = -b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = -b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx -= A_data[j] * x_data[A_j[j]];
}
y_data[m] += tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
} // y = -A*x - b
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = alpha * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 |
y_data[i] = alpha * b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += alpha * tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
else
{
if (alpha == 1.0)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = beta * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = beta * b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | // y = A*x + beta*b
else if (-1 == alpha)
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = -temp * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 |
y_data[i] = -temp * b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx -= A_data[j] * x_data[A_j[j]];
}
y_data[m] += tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
} // y = -A*x - temp*b
else
{
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rows; i++)
{
y_data[i] = beta * b_data[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE | 100 | {
y_data[i] = beta * b_data[i];
}
#ifdef HYPRE_USING_OPENMP
<LOOP-START>for (i = 0; i < num_rownnz; i++)
{
m = A_rownnz[i];
tempx = 0.0;
for (j = A_i[m]; j < A_i[m + 1]; j++)
{
tempx += A_data[j] * x_data[A_j[j]];
}
y_data[m] += alpha * tempx;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,m,tempx) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/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;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 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;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 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;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/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;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/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; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 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; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/csr_matvec.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | ker_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; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/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> |
hypre-space/hypre/src/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; i++)
if (CF_marker_x[i] == fpt) { y_data[i] *= alpha; }<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector_batched.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | 0; j < k - 7; j += 8)
{
jstart = j * size;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += alpha[j] * x_data[jstart + i] + alpha[j + 1] * x_data[jstart + i + size]
+ alpha[j + 2] * x_data[(j + 2) * size + i] + alpha[j + 3] * x_data[(j + 3) * size + i]
+ alpha[j + 4] * x_data[(j + 4) * size + i] + alpha[j + 5] * x_data[(j + 5) * size + i]
+ alpha[j + 6] * x_data[(j + 6) * size + i] + alpha[j + 7] * x_data[(j + 7) * size + i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector_batched.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
}
if (restk == 1)
{
jstart = (k - 1) * size;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += alpha[k - 1] * x_data[jstart + i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector_batched.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
else if (restk == 2)
{
jstart = (k - 2) * size;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += alpha[k - 2] * x_data[jstart + i] + alpha[k - 1] * x_data[jstart + size + i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector_batched.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
else if (restk == 3)
{
jstart = (k - 3) * size;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += alpha[k - 3] * x_data[jstart + i] + alpha[k - 2] * x_data[jstart + size + i] + alpha[k
- 1] *
x_data[(k - 1) * size + i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
hypre-space/hypre/src/seq_mv/vector_batched.c | #pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE | 100 | }
else if (restk == 4)
{
jstart = (k - 4) * size;
#if defined(HYPRE_USING_OPENMP)
<LOOP-START>for (i = 0; i < size; i++)
{
y_data[i] += alpha[k - 4] * x_data[(k - 4) * size + i] + alpha[k - 3] * x_data[(k - 3) * size + i]
+ alpha[k - 2] * x_data[(k - 2) * size + i] + alpha[k - 1] * x_data[(k - 1) * size + i];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) HYPRE_SMP_SCHEDULE<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.