filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) | 100 | 32_t v=0; v < nvtxs; ++v) {
xadj[1+v] = graph->xadj[v];
}
/* shift adjncy values by 1 */
<LOOP-START>for(ssize_t e=0; e < nedges; ++e) {
++(graph->adjncy[e]);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) reduction(+:nnz) | 100 | int64_t count_nnz(
int64_t const N,
int32_t const * const supports)
{
int64_t nnz = 0;
<LOOP-START>for(int64_t e = 0; e < N; ++e) {
if(supports[e] > 0) {
++nnz;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(+:nnz)<OMP-END> |
KarypisLab/K-Truss/src/util.c | #pragma omp parallel for schedule(static) reduction(+:total_support) | 100 | support(
int64_t const N,
int32_t const * const supports)
{
int64_t total_support = 0;
<LOOP-START>for(int64_t e = 0; e < N; ++e) {
if(supports[e] > 0) {
total_support += supports[e];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(+:total_support)<OMP-END> |
KarypisLab/K-Truss/src/kt_sbucket.c | #pragma omp parallel for schedule(static, 1) | 100 | st));
++big_slist; /* +1 to allow slist[-1] to be valid */
/* allocate each thread-bucket */
<LOOP-START>for(int bucket=0; bucket < nbuckets; ++bucket) {
support_bucket_t * sbucket = &(sbuckets[bucket]);
sbucket->nsupports = nsupports;
sbucket->nowned_edges = 0;
sbucket->slist = big_slist;
sb... |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for schedule(dynamic, DYNAMIC_CHUNK) | 100 | >ktmax = ktmax;
vault->ktedges = gk_malloc(xadj[nvtxs] * sizeof(*vault->ktedges), "ktedges");
<LOOP-START>for(int32_t v=0; v < nvtxs; ++v) {
for(ssize_t e = xadj[v]; e < xadj[v+1]; ++e) {
/* -1 to revert the shift-by-one ordering */
int32_t const v1 = vault->iperm[v];
int32_t const v2 = vaul... |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for schedule(dynamic, DYNAMIC_CHUNK) | 100 | to 'u' vertices in ugraph. */
int32_t * u_vtxs = gk_malloc(nedges * sizeof(*u_vtxs), "u_vtxs");
<LOOP-START>for(int32_t v=0; v < nvtxs; ++v) {
for(ssize_t e = vault->ugraph->xadj[v]; e < vault->ugraph->xadj[v+1]; ++e) {
u_vtxs[e] = v;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynami... |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for schedule(dynamic, DYNAMIC_CHUNK) | 100 | graph */
int64_t * lgraph_maps = gk_malloc(nedges * sizeof(*lgraph_maps),
"lgraph_maps");
<LOOP-START>for(int32_t v=0; v < nvtxs; ++v) {
for(ssize_t le = vault->lgraph->xadj[v]; le < vault->lgraph->xadj[v+1];
++le) {
int32_t const u = vault->lgraph->adjncy[le];
/* find corresponding ed... |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for schedule(static) | 100 | gk_malloc(nedges * sizeof(*need_update),
"need_update_new");
/* reset update messages */
<LOOP-START>for(int64_t e=0; e < nedges; ++e) {
need_update[e] = 1;
need_update_new[e] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for schedule(dynamic, DYNAMIC_CHUNK) \ | 100 | g);
bool done = false;
/*
* Main loop.
*/
while(!done) {
int64_t nchanges = 0;
<LOOP-START>reduction(+: nchanges)
for(int64_t e=0; e < nedges; ++e) {
if(!need_update[e]) {
continue;
}
int const tid = omp_get_thread_num();
int32_t const new_support = p_update_edg... |
KarypisLab/K-Truss/src/and.c | #pragma omp parallel for reduction(max: max_ktruss) | 100 | mp;
} /* end main loop */
gk_stopwctimer(vault->timer_ktpeeling);
int32_t max_ktruss = 0;
<LOOP-START>for(int64_t e=0; e < nedges; ++e) {
/* +2 because of the k-truss definition... */
supports[e] += 2;
max_ktruss = gk_max(max_ktruss, supports[e]);
}<LOOP-END> <OMP-START>#pragma omp parallel for ... |
KarypisLab/K-Truss/src/kt.c | #pragma omp parallel for schedule(static) reduction(+:total_sup) | 100 | shead[k] = ti;
slist[ti].peid = -1;
/* add up sups[:] */
int64_t total_sup = 0;
<LOOP-START>for(int64_t e = 0; e < nedges; ++e) {
if(sups[e] >= 0) {
total_sup += sups[e];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(+:total_sup)<OMP-END> |
KarypisLab/K-Truss/src/kt.c | #pragma omp parallel for schedule(static) reduction(+:total_sup) | 100 | goto BACK;
}
gk_stopwctimer(timer_currk);
/* add up sups[:] */
total_sup = 0;
<LOOP-START>for(int64_t e = 0; e < nedges; ++e) {
if(sups[e] >= 0) {
total_sup += sups[e];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static) reduction(+:total_sup)<OMP-END> |
KarypisLab/K-Truss/src/multistage-peeling.c | #pragma omp parallel for | 100 | 2_t * const restrict supports = dgraph->supports;
/* initialize the start of each adj. list */
<LOOP-START>for(int32_t vi=0; vi < nvtxs; ++vi) {
dgraph->xaii[vi].start = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
KarypisLab/K-Truss/src/multistage-peeling.c | #pragma omp parallel for schedule(static) | 100 | s after peeling: %"PRId64"\n", ntriangles);
/* adjust for */
if(params->outfile != NULL) {
<LOOP-START>for(int64_t e=0; e < nedges; ++e) {
dgraph->supports[e] += 2;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
kaserashi/Parallelization-of-Smith-Waterman-Algorithm/parallelcode.c | #pragma omp parallel for | 100 | ray[i][0]=0;
}
compval = 0;
//parallelization of for loop to minimizethe time if done serially
<LOOP-START>for(i = 1; i <= lenA; ++i)
{
#pragma omp parallel for
for(j = 1; j <= lenB; ++j)
{
if(FASTA1[i-1] == FASTA2[j-1])
{
compval = (SWArray[i-1][j-1] + Match);
}
if(compval... |
kaserashi/Parallelization-of-Smith-Waterman-Algorithm/parallelcode.c | #pragma omp parallel for | 100 | minimizethe time if done serially
#pragma omp parallel for
for(i = 1; i <= lenA; ++i)
{
<LOOP-START>for(j = 1; j <= lenB; ++j)
{
if(FASTA1[i-1] == FASTA2[j-1])
{
compval = (SWArray[i-1][j-1] + Match);
}
if(compval < ((SWArray[i-1][j]) + Gap))
{
compval = ((SWArray[i-1... |
rohinarora/OpenMP/Dense_MatMul_OpenMP/M-M_blocked_omp.c | #pragma omp parallel for private(i, j, k, kk, jj, sum) shared(a, b, c, en) default(none) collapse(3) schedule(dynamic, 4) | 100 | is is the only portion of the code you should modify to improve performance. */
//double x = 0;
<LOOP-START>{
for (kk = 0; kk < en; kk += B)
for (jj = 0; jj < en; jj += B)
for (i = 0; i < M; i++)
for (j = jj; j < jj + B; j++)
{
... |
rohinarora/OpenMP/Dense_MatMul_OpenMP/M-M_omp.c | #pragma omp parallel for private(x, i, j, k) | 100 | This is the only portion of the code you should modify to improve performance. */
double x = 0;
<LOOP-START>{
for (i = 0; i < M; i++)
{
for (j = 0; j < M; j++)
{
x = 0;
for (k = 0; k < M; k++)
{
x += a[i][k] ... |
rohinarora/OpenMP/Code/src/3_mandel_fix.c | #pragma omp parallel for default(shared) firstprivate(eps) private(c, i, j) | 100 | ains the Mandelbrot set,
// testing each point to see whether it is inside or outside the set.
<LOOP-START>for (i = 0; i < NPOINTS; i++)
{
for (j = 0; j < NPOINTS; j++)
{
c.r = -2.0 + 2.5 * (double)(i) / (double)(NPOINTS) + eps;
c.i = 1.125 * (double)(j) / (double)(NPOINTS) + eps;
testp... |
rohinarora/OpenMP/Code/src/2_parallel_pi_v4_2.c | #pragma omp parallel for reduction(+ \ | 100 |
step = 1.0 / (double)num_steps;
omp_set_num_threads(NUM_THREADS);
start_time = omp_get_wtime();
<LOOP-START>: sum) private(x, i)
{
for (i = 1; i <= num_steps; i++)
{
x = (i - 0.5) * step; // or (i+0.5)*step; if i starts from 0
sum += 4.0 / (1.0 + x * x); // 4.0 and 1.0 ensure this is double
}
}<LOOP-... |
rohinarora/OpenMP/Code/src/3_mandel_bug.c | #pragma omp parallel for default(shared) private(c,eps) | 100 | ntains the Mandelbrot set,
// testing each point to see whether it is inside or outside the set.
<LOOP-START>for (i=0; i<NPOINTS; i++) {
for (j=0; j<NPOINTS; j++) {
c.r = -2.0+2.5*(double)(i)/(double)(NPOINTS)+eps;
c.i = 1.125*(double)(j)/(double)(NPOINTS)+eps;
testpoint();
}
}<LOOP... |
XiangRongLin/grayscale-conversion/cpu/algorithms/memory_simd_sse.c | #pragma omp parallel for | 100 | _thread_aligned = ((int)pixel_per_thread_unaligned / floats_per_operation) * floats_per_operation;
<LOOP-START>for (int thread = 0; thread < threads; thread++)
{
int end;
if (thread + 1 == threads)
{
end = ((int)size / floats_per_operation) * floats_per_operation;
}
... |
XiangRongLin/grayscale-conversion/cpu/algorithms/openmp_baseline.c | #pragma omp parallel for collapse(2) | 100 | line(unsigned char *img, int width, int height, int channels, int threads, unsigned char *result)
{
<LOOP-START>for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
result[y * width + x] =
0.2126 * img[(y * width + x) * channels] // red
... |
XiangRongLin/grayscale-conversion/cpu/algorithms/memory.c | #pragma omp parallel for | 100 | nnels, int threads, unsigned char *result)
{
int pixel_per_thread = (width * height) / threads;
<LOOP-START>for (int thread = 0; thread < threads; thread++)
{
int end;
if (thread + 1 == threads)
{
end = width * height;
}
else
{
end = pixel_... |
XiangRongLin/grayscale-conversion/cpu/algorithms/memory_simd_fma.c | #pragma omp parallel for | 100 | 0.7152, 0.7152, 0.7152, 0.7152);
__m128 b_factor = _mm_set_ps(0.0722, 0.0722, 0.0722, 0.0722);
<LOOP-START>for (int thread = 0; thread < threads; thread++)
{
int end;
if (thread + 1 == threads)
{
end = ((int)size / floats_per_operation) * floats_per_operation;
}
... |
XiangRongLin/grayscale-conversion/cpu/algorithms/memory_simd_avx.c | #pragma omp parallel for | 100 | er_thread_aligned = ((int)pixel_per_thread_unaligned / pixel_per_iteration) * pixel_per_iteration;
<LOOP-START>for (int thread = 0; thread < threads; thread++)
{
int end;
if (thread + 1 == threads)
{
end = ((int)size / pixel_per_iteration) * pixel_per_iteration;
}
... |
carlotacb/PAR-Laboratoris/LAB 4/session_codes/lab4/multisort-omp-op1-2.c | #pragma omp parallel for | 100 | ase
basicsort(n, data);
}
}
static void initialize(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
if (i==0) {
data[i] = rand();
} else {
data[i] = ((data[i-1]+1) * i * 104723L) % N;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-... |
carlotacb/PAR-Laboratoris/LAB 4/session_codes/lab4/multisort-omp-op1-2.c | #pragma omp parallel for | 100 | * i * 104723L) % N;
}
}
}
static void clear(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
data[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
carlotacb/PAR-Laboratoris/LAB 3/codis/for/mandel-omp-for-row.c | #pragma omp parallel for schedule(runtime) private(col) | 100 | or)
#else
int ** output)
#endif
{
/* Calculate points and save/display */
<LOOP-START>for (row = 0; row < height; ++row) {
for (col = 0; col < width; ++col) {
complex z, c;
z.real = z.imag = 0;
/* Scale display coordinates to actual region */
... |
carlotacb/PAR-Laboratoris/LAB 3/codis/for/mandel-omp-for-point.c | #pragma omp parallel for schedule(runtime) firstprivate(row) | 100 | dif
{
/* Calculate points and save/display */
for (row = 0; row < height; ++row) {
<LOOP-START>for (col = 0; col < width; ++col) {
complex z, c;
z.real = z.imag = 0;
/* Scale display coordinates to actual region */
c.real = real_min + ((double) ... |
gurbaaz27/CS433A-Design-Exercises/assignment3/Q2_openmp.cpp | #pragma omp parallel for num_threads (t) private(i, j) | 100 | = (float)(i)/(n*n);
}
gettimeofday(&tv0, &tz0);
// row version
int i, j;
<LOOP-START>for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
y[i] += A[i][j] * x[j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads (t) private(i, j)<OMP-END> |
arslansadiq/Parallel-Programming-TUM/Assignment8_Loop_Fusion/student/loop_fusion_par.c | #pragma omp parallel for num_threads(num_threads) | 100 | gned long **a, unsigned long **b, unsigned long **c, unsigned long **d, int N, int num_threads) {
<LOOP-START>for (int i = 1; i < N; i++) {
int j = 1;
a[i][j] = 2 * b[i][j];
d[i][j] = a[i][j] * c[i][j];
c[i][j - 1] = a[i][j - 1] - 2 * b[i][j + 1];
for (j = 2; j < N - 1; j++) {
a[i][j] = 2 * b[i][j];
... |
arslansadiq/Parallel-Programming-TUM/Assignment4_Openmp_1/student/x_gradient_par.h | #pragma omp parallel for schedule (dynamic,5) | 100 | typename channel_type<DstView>::type dst_channel_t;
omp_set_num_threads(num_threads);
<LOOP-START>for (int y=0; y<src.height(); ++y) {
typename SrcView::x_iterator src_it = src.row_begin(y);
typename DstView::x_iterator dst_it = dst.row_begin(y);
for (int x=1; x<src.width()-1; ++x... |
arslansadiq/Parallel-Programming-TUM/Assignment12_Hybrid/helper.c | #pragma omp parallel for num_threads(num_threads) reduction(+:heat) | 100 | t_omp(double *h_new, int n, int num_threads)
{
double heat = 0.0; // total heat in system
//<LOOP-START>for (int i = 1; i < n + 1; ++i)
{
for (int j = 1; j < n + 1; ++j)
{
heat += h_new[map(i, j, n+2)];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(num_threads) ... |
arslansadiq/Parallel-Programming-TUM/Assignment6_OpenMP_First touch/student/laplace_par.h | #pragma omp parallel for schedule(static) proc_bind(spread) | 100 | <int SIZE>
inline void initialize(double a[SIZE + 2][SIZE + 2], double b[SIZE + 2][SIZE + 2])
{
<LOOP-START>for (int i = 0; i < SIZE + 2; i++)
for (int j = 0; j < SIZE + 2; j++)
{
a[i][j] = 0.0;
b[i][j] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(s... |
arslansadiq/Parallel-Programming-TUM/Assignment6_OpenMP_First touch/student/laplace_par.h | #pragma omp parallel for schedule(static) proc_bind(spread) | 100 | double a[SIZE + 2][SIZE + 2], double b[SIZE + 2][SIZE + 2], int n)
{
if (n % 2 == 0)
{
<LOOP-START>for (int i = 1; i < SIZE + 1; i++)
for (int j = 1; j < SIZE + 1; j++)
b[i][j] = (a[i + 1][j] + a[i - 1][j] + a[i][j - 1] + a[i][j + 1]) / 4.0;
}
else
{
#pragma omp... |
tudasc/MPI-Corrbench/micro-benches/0-level/openmp/threading/missing_init_thread.c | #pragma omp parallel for num_threads(NUM_THREADS) | 100 | uffer_out[10], buffer_in[10];
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
<LOOP-START>for (int i = 0; i < 10; i++) {
buffer_out[i] = i * 10;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NUM_THREADS)<OMP-END> |
felixarpa/PAR-Lab/deliverables/par2312-lab5/code/solver-omp.c | #pragma omp parallel for | 100 | matrix into another
*/
void copy_mat (double *u, double *v, unsigned sizex, unsigned sizey)
{
<LOOP-START>for (int i = 1; i <= sizex - 2; i++) {
for (int j = 1; j <= sizey-2; j++) {
v[i * sizey + j] = u[i * sizey + j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
felixarpa/PAR-Lab/deliverables/par2312-lab5/code/solver-omp.c | #pragma omp parallel for private(diff) reduction(+:sum) | 100 | ed sizex, unsigned sizey)
{
double diff, sum=0.0;
int howmany = omp_get_max_threads();
<LOOP-START>for (int blockid = 0; blockid < howmany; ++blockid) {
int i_start = lowerb(blockid, howmany, sizex);
int i_end = upperb(blockid, howmany, sizex);
for (int i = max(1, i_start); i <= min(sizex - ... |
felixarpa/PAR-Lab/deliverables/par2312-lab5/code/solver-omp.c | #pragma omp parallel for schedule(static) private(diff, unew) reduction(+:sum) | 100 | for(int i = 0; i < howmany; ++i) {
processedBlocks[i] = 0;
}
int nBlocs = 32;
<LOOP-START>for (int i = 0; i < howmany; ++i) {
int ii_start = lowerb(i, howmany, sizex);
int ii_end = upperb(i, howmany, sizex);
for (int j = 0; j < nBlocs; j++){
int jj_start = lower... |
felixarpa/PAR-Lab/deliverables/par2312-lab4/code/multisort-omp-tree-optional.c | #pragma omp parallel for | 100 | ase
basicsort(n, data);
}
}
static void initialize(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
if (i==0) {
data[i] = rand();
} else {
data[i] = ((data[i-1]+1) * i * 104723L) % N;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-... |
felixarpa/PAR-Lab/deliverables/par2312-lab4/code/multisort-omp-tree-optional.c | #pragma omp parallel for | 100 | * i * 104723L) % N;
}
}
}
static void clear(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
data[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
felixarpa/PAR-Lab/deliverables/par2312-lab4/code/multisort-omp-tree.c | #pragma omp parallel for schedule(static, 8) | 100 | ase
basicsort(n, data);
}
}
static void initialize(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
if (i==0) {
data[i] = rand();
} else {
data[i] = ((data[i-1]+1) * i * 104723L) % N;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for sche... |
felixarpa/PAR-Lab/deliverables/par2312-lab4/code/multisort-omp-tree.c | #pragma omp parallel for schedule(static, 8) | 100 | * i * 104723L) % N;
}
}
}
static void clear(long length, T data[length]) {
long i;
<LOOP-START>for (i = 0; i < length; i++) {
data[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static, 8)<OMP-END> |
felixarpa/PAR-Lab/boada/lab5/solver-omp.c | #pragma omp parallel for | 100 | matrix into another
*/
void copy_mat (double *u, double *v, unsigned sizex, unsigned sizey)
{
<LOOP-START>for (int i=1; i<=sizex-2; i++)
for (int j=1; j<=sizey-2; j++)
v[ i*sizey+j ] = u[ i*sizey+j ];
}
/*
* Blocked Jacobi solver: one iteration step
*/
double relax_jacobi (double *u, doubl... |
felixarpa/PAR-Lab/boada/lab5/solver-omp.c | #pragma omp parallel for private(diff) reduction(+:sum) | 100 | sizex, unsigned sizey)
{
double diff, sum=0.0;
int howmany = omp_get_max_threads();
<LOOP-START>for (int blockid = 0; blockid < howmany; ++blockid) {
int i_start = lowerb(blockid, howmany, sizex);
int i_end = upperb(blockid, howmany, sizex);
for (int i=max(1, i_start); i<= min(sizex-2,... |
felixarpa/PAR-Lab/boada/lab5/solver-omp.c | #pragma omp parallel for schedule(static) private(diff,unew) reduction(+:sum) | 100 | ny];
for(int i = 0; i < howmany; ++i) processedBlocks[i] = 0;
int nBlocs = 8;
<LOOP-START>for (int i = 0; i < howmany; ++i) {
int ii_start = lowerb(i, howmany, sizex);
int ii_end = upperb(i, howmany, sizex);
for (int j = 0; j < nBlocs; j++){
int jj_start = lower... |
felixarpa/PAR-Lab/boada/lab2/openmp/worksharing/4.collapse.c | #pragma omp parallel for private(j) | 100 | to make it correct. */
int main()
{
int i,j;
omp_set_num_threads(8);
<LOOP-START>for (i=0; i < N; i++) {
for (j=0; j < N; j++) {
int id=omp_get_thread_num();
printf("(%d) Iter (%d %d)\n",id,i,j);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) <OMP-END> |
felixarpa/PAR-Lab/boada/lab2/openmp/worksharing/6.doacross.c | #pragma omp parallel for ordered(1) schedule(dynamic) | 100 | float a[N], b[N], c[N];
float a1[M][M], b1[M][M], c1[M][M];
omp_set_num_threads(8);
<LOOP-START>for (int i=1; i<N; i++) {
a[i] = 1.3;
printf("Outside from %d executing %d\n", omp_get_thread_num(), i);
#pragma omp ordered depend(sink: i-2)
{
printf("Inside from %d execu... |
felixarpa/PAR-Lab/boada/lab2/openmp/worksharing/6.doacross.c | #pragma omp parallel for ordered(2) schedule(dynamic) | 100 | b[i] = a[i] * b[i-1];
}
#pragma omp ordered depend(source)
c[i] = b[i] * 0.1234;
}
<LOOP-START>for (int i=1; i<M; i++) {
for (int j=1; j<M; j++) {
a1[i][j] = 3.45;
#pragma omp ordered depend(sink: i-1,j) depend(sink: i,j-1)
{
printf("Compu... |
felixarpa/PAR-Lab/boada/lab2/openmp/worksharing/1.for.c | #pragma omp parallel for | 100 | ",id,i);
}
}
printf("\nGoing to distribute iterations in second loop ...\n");
<LOOP-START>for (i=0; i < N+3; i++) {
int id=omp_get_thread_num();
printf("(%d) gets iteration %d\n",id,i);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphCSR.c | #pragma omp parallel for | 100 | es_array->inverse_label_array;
label_array_el = graphCSR->sorted_edges_array->label_array;
<LOOP-START>for (v = 0; v < num_vertices; ++v)
{
uint32_t u = label_array_el[v];
uint32_t t = label_array_iel[v];
inverse_label_array_el[u] = t;
}<LOOP-END> <OMP-START>#pragma omp paralle... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphCSR.c | #pragma omp parallel for | 100 | uint32_t t = label_array_iel[v];
inverse_label_array_el[u] = t;
}
#if DIRECTED
<LOOP-START>for (v = 0; v < num_vertices; ++v)
{
uint32_t u = label_array_el[v];
uint32_t t = label_array_iel[v];
inverse_label_array_iel[t] = u;
}<LOOP-END> <OMP-START>#pragma omp parall... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | geList *edgeList)
{
uint32_t i;
uint32_t src;
#if DIRECTED
uint32_t dest;
#endif
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
#pragma omp atomic update
graphAdjArrayList->vertices[src].out_degree++;
#if DIRECTED
dest... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | djArrayList *graphAdjArrayList, struct EdgeList *edgeList)
{
uint32_t i;
uint32_t src;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
#pragma omp atomic update
graphAdjArrayList->vertices[src].out_degree++;
}<LOOP-END> <OMP-STA... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | st *graphAdjArrayList, struct EdgeList *inverseEdgeList)
{
uint32_t i;
uint32_t dest;
<LOOP-START>for(i = 0; i < inverseEdgeList->num_edges; i++)
{
dest = inverseEdgeList->edges_array_src[i];
#pragma omp atomic update
graphAdjArrayList->vertices[dest].in_degree++;
}<LOOP... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | *graphAdjArrayListEdgeAllocate(struct GraphAdjArrayList *graphAdjArrayList)
{
uint32_t v;
<LOOP-START>for(v = 0; v < graphAdjArrayList->num_vertices; v++)
{
adjArrayListCreateNeighbourList(&(graphAdjArrayList->vertices[v]));
#if DIRECTED
graphAdjArrayList->vertices[v].in_degree = 0;
... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | geAllocateInodes(struct GraphAdjArrayList *graphAdjArrayList)
{
#if DIRECTED
uint32_t v;
// <LOOP-START>for(v = 0; v < graphAdjArrayList->num_vertices; v++)
{
adjArrayListCreateNeighbourListInNodes(&(graphAdjArrayList->vertices[v]));
graphAdjArrayList->vertices[v].in_degree = 0;
}<L... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | rrayListEdgeAllocateOutNodes(struct GraphAdjArrayList *graphAdjArrayList)
{
uint32_t v;
// <LOOP-START>for(v = 0; v < graphAdjArrayList->num_vertices; v++)
{
adjArrayListCreateNeighbourListOutNodes(&(graphAdjArrayList->vertices[v]));
graphAdjArrayList->vertices[v].out_degree = 0; // will ... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjArrayList.c | #pragma omp parallel for | 100 | ;
#if DIRECTED
uint32_t dest;
uint32_t in_degree;
#endif
uint32_t out_degree;
// <LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
// out_degree = __sync_fetch_and_add(&(graphAdjArrayList->vertices[src].out_degree), 1);y
out_de... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/vertex.c | #pragma omp parallel for default(none) private(vertex_id) shared(vertices,graph) | 100 | = i;
}
}
}
}
#if DIRECTED
if(!inverse)
{
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
graph->inverse_vertices->in_degree[vertex_id] = vertices->out_degree[vertex_id];
}<LOOP-END> <OMP-START>#pragma ... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/vertex.c | #pragma omp parallel for default(none) private(vertex_id) shared(vertices,graph) | 100 | es->in_degree[vertex_id] = vertices->out_degree[vertex_id];
}
}
else
{
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
graph->vertices->in_degree[vertex_id] = vertices->out_degree[vertex_id];
}<LOOP-END> <OMP-START>#pragma omp para... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/bitmap.c | #pragma omp parallel for | 100 | ord - 1) / kBitsPerWord)));
// uint32_t *word = bitmap->bitarray;
// uint32_t i;
// <LOOP-START>// for(i= 0 ; i <((bitmap->size+kBitsPerWord - 1)/kBitsPerWord); i++){
// word[i] = 0;
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/bitmap.c | #pragma omp parallel for reduction(+:numSetBits) schedule(dynamic,256) | 100 | nt32_t getNumOfSetBits (struct Bitmap *bitmap)
{
uint32_t i;
uint32_t numSetBits = 0;
<LOOP-START>for(i = 0 ; i < (bitmap->size); i++)
{
if(getBit(bitmap, i))
numSetBits++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:numSetBits) schedule(dynamic,256)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/worklist.c | #pragma omp parallel for | 100 | 2 = workList_temp;
}
void resetWorkList(uint8_t *workList, uint32_t size)
{
uint32_t i;
<LOOP-START>for(i = 0; i < size ; i++)
{
workList[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/worklist.c | #pragma omp parallel for | 100 | ist[i] = 0;
}
}
void setWorkList(uint8_t *workList, uint32_t size)
{
uint32_t i;
<LOOP-START>for(i = 0; i < size ; i++)
{
workList[i] = 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) shared(grid,totalPartitions) private(i) | 100 | itions = 0;
totalPartitions = grid->num_partitions * grid->num_partitions;
uint32_t i;
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
grid->activePartitions[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(grid,totalPartitions) private(i)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) shared(grid,totalPartitions,row) private(i,Partition_idx) | 100 | uint32_t i;
uint32_t totalPartitions = 0;
totalPartitions = grid->num_partitions;
// <LOOP-START>for ( i = 0; i < totalPartitions; ++i)
{
Partition_idx = (row * totalPartitions) + i;
if(grid->partitions[Partition_idx].edgeList->num_edges)
{
if(!getBit(grid->activ... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) shared(grid,totalPartitions,row) private(i,Partition_idx) | 100 | uint32_t i;
uint32_t totalPartitions = 0;
totalPartitions = grid->num_partitions;
// <LOOP-START>for ( i = 0; i < totalPartitions; ++i)
{
Partition_idx = (row * totalPartitions) + i;
if(grid->partitions[Partition_idx].edgeList->num_edges)
{
grid->activePartitions[... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i) shared(totalPartitions,grid) | 100 | id->num_vertices);
grid->activePartitionsMap = newBitmap(totalPartitions);
uint32_t i;
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
grid->partitions[i].num_edges = 0;
grid->partitions[i].num_vertices = 0; /* code */
grid->activePartitions[i] = 0;
}<LOOP-END> <OMP... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i) shared(grid) | 100 | ->partitions[i].num_vertices = 0; /* code */
grid->activePartitions[i] = 0;
}
<LOOP-START>for (i = 0; i < grid->num_vertices ; ++i)
{
grid->out_degree[i] = 0;
grid->in_degree[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(grid)<OMP... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,grid) | 100 | Grid *grid, struct EdgeList *edgeList)
{
uint32_t i;
uint32_t src;
uint32_t dest;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
#pragma omp atomic update
grid->out_degree[src]++;
... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i) shared(totalPartitions,grid) | 100 | m_vertices = 0;
uint32_t totalPartitions = grid->num_partitions * grid->num_partitions;
// <LOOP-START>#pragma omp parallel for default(none) private(i,src,dest,num_vertices) shared(totalPartitions,grid) schedule(dynamic,1024)
for ( j = 0; j < totalPartitions; ++j)
{
num_vertices = 0;
/... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i,src,dest,num_vertices) shared(totalPartitions,grid) schedule(dynamic,1024) | 100 | titions;
// #pragma omp parallel for default(none) private(i) shared(totalPartitions,grid)
<LOOP-START>for ( j = 0; j < totalPartitions; ++j)
{
num_vertices = 0;
// #pragma omp parallel for default(none) private(i,src,dest) shared(j,grid) schedule(dynamic,1024) reduction(max:num_vertices)
... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i,src,dest) shared(j,grid) schedule(dynamic,1024) reduction(max:num_vertices) | 100 | dynamic,1024)
for ( j = 0; j < totalPartitions; ++j)
{
num_vertices = 0;
// <LOOP-START>for(i = 0; i < grid->partitions[j].edgeList->num_edges; i++)
{
src = grid->partitions[j].edgeList->edges_array_src[i];
dest = grid->partitions[j].edgeList->edges_array_des... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i,row,col,src,dest,Partition_idx) shared(num_vertices, num_partitions,edgeList,grid) | 100 | titions;
uint32_t num_vertices = grid->num_vertices;
uint32_t row;
uint32_t col;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
// __sync_fetch_and_add(&grid->out_degree[src],1);
/... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(Edge_idx,i,row,col,src,dest,Partition_idx) shared(num_vertices, num_partitions,edgeList,grid) | 100 | tions;
uint32_t num_vertices = grid->num_vertices;
uint32_t row;
uint32_t col;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
row = getPartitionID(num_vertices, num_partitions, src);
... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/grid.c | #pragma omp parallel for default(none) private(i) shared(totalPartitions,grid) | 100 | {
uint32_t i;
uint32_t totalPartitions = grid->num_partitions * grid->num_partitions;
<LOOP-START>for ( i = 0; i < totalPartitions; ++i)
{
grid->partitions[i].edgeList = newEdgeList(grid->partitions[i].num_edges);
grid->partitions[i].edgeList->num_vertices = grid->partitions[i].num_ve... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjLinkedList.c | #pragma omp parallel for | 100 | ices = (struct AdjLinkedList *) my_malloc( V * sizeof(struct AdjLinkedList));
uint32_t i;
<LOOP-START>for(i = 0; i < V; i++)
{
graphAdjLinkedList->vertices[i].outNodes = NULL;
graphAdjLinkedList->vertices[i].out_degree = 0;
#if DIRECTED
graphAdjLinkedList->vertices[i].inNodes = N... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjLinkedList.c | #pragma omp parallel for | 100 | WEIGHTED
graphAdjLinkedList->max_weight = edgeList->max_weight;
#endif
uint32_t i;
<LOOP-START>for(i = 0; i < graphAdjLinkedList->num_vertices; i++)
{
graphAdjLinkedList->vertices[i].outNodes = NULL;
graphAdjLinkedList->vertices[i].out_degree = 0;
#if DIRECTED
graphAdjLink... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjLinkedList.c | #pragma omp parallel for | 100 | ex_lock = (omp_lock_t *) my_malloc( graphAdjLinkedList->num_vertices * sizeof(omp_lock_t));
<LOOP-START>for (i = 0; i < graphAdjLinkedList->num_vertices; i++)
{
omp_init_lock(&(vertex_lock[i]));
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjLinkedList.c | #pragma omp parallel for | 100 | raphAdjLinkedList->num_vertices; i++)
{
omp_init_lock(&(vertex_lock[i]));
}
// <LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
adjLinkedListAddEdge(graphAdjLinkedList, edgeList, i, vertex_lock);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/graphAdjLinkedList.c | #pragma omp parallel for | 100 | i++)
{
adjLinkedListAddEdge(graphAdjLinkedList, edgeList, i, vertex_lock);
}
<LOOP-START>for (i = 0; i < graphAdjLinkedList->num_vertices; i++)
{
omp_destroy_lock(&(vertex_lock[i]));
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/arrayQueue.c | #pragma omp parallel for | 100 | ;
}
void arrayQueueGenerateBitmap(struct ArrayQueue *q)
{
uint32_t v;
uint32_t i;
<LOOP-START>for(i = q->head ; i < q->tail; i++)
{
v = q->queue[i];
setBitAtomic(q->q_bitmap, v);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/arrayQueue.c | #pragma omp parallel for default(none) shared(q,b) private(v,i) | 100 | arrayQueueToBitmap(struct ArrayQueue *q, struct Bitmap *b)
{
uint32_t v;
uint32_t i;
<LOOP-START>for(i = q->head ; i < q->tail; i++)
{
v = q->queue[i];
setBitAtomic(b, v);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(q,b) private(v,i)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/arrayQueue.c | #pragma omp parallel for default(none) shared(q,b,labels) private(v,i,inv_u) num_threads(num_threads_max) | 100 | t v;
uint32_t i;
uint32_t inv_u;
uint32_t num_threads_max = omp_get_max_threads();
<LOOP-START>for(i = q->head ; i < q->tail; i++)
{
v = q->queue[i];
inv_u = labels[v];
setBitAtomic(b, inv_u);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(q,b,label... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | t->edges_array_weight = (float *) my_malloc(num_edges * sizeof(float));
#endif
uint32_t i;
<LOOP-START>for(i = 0; i < num_edges; i++)
{
newEdgeList->edges_array_dest[i] = 0;
newEdgeList->edges_array_src[i] = 0;
#if WEIGHTED
newEdgeList->edges_array_weight[i] = 0;
}<LOOP-END> <O... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | ->inverse_label_array = (uint32_t *) my_malloc(tempEdgeList->num_vertices * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
tempEdgeList->mask_array[i] = edgeList->mask_array[i] ;
tempEdgeList->label_array[i] = edgeList->label_array[i];
tempEdgeList->inver... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for reduction(max:num_vertices) | 100 | uint32_t i;
uint32_t num_vertices = 0;
#if WEIGHTED
float max_weight = 0;
#endif
// <LOOP-START>for(i = 0; i < num_edges; i++)
{
src = buf_pointer[((offset) * i) + 0];
dest = buf_pointer[((offset) * i) + 1];
// printf(" %u %lu -> %lu \n",i,src,dest);
#if DIRECTED
if(!... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | List->inverse_label_array = (uint32_t *) my_malloc(edgeList->num_vertices * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
edgeList->mask_array[i] = 0;
edgeList->label_array[i] = i;
edgeList->inverse_label_array[i] = i;
}<LOOP-END> <OMP-START>#pragma o... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | {
edgeList->mask_array = (uint32_t *) my_malloc(num_vertices * sizeof(uint32_t));
<LOOP-START>for ( i = 0; i < num_vertices; ++i)
{
edgeList->mask_array[i] = edgeListmem->mask_array[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | {
edgeList->label_array = (uint32_t *) my_malloc(num_vertices * sizeof(uint32_t));
<LOOP-START>for ( i = 0; i < num_vertices; ++i)
{
edgeList->label_array[i] = edgeListmem->label_array[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for | 100 | edgeList->inverse_label_array = (uint32_t *) my_malloc(num_vertices * sizeof(uint32_t));
<LOOP-START>for ( i = 0; i < num_vertices; ++i)
{
edgeList->inverse_label_array[i] = edgeListmem->inverse_label_array[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/edgeList.c | #pragma omp parallel for private(src,dest) | 100 | edgeList->inverse_label_array[i] = edgeListmem->inverse_label_array[i];
}
}
<LOOP-START>for(i = 0; i < num_edges; i++)
{
src = edgeListmem->edges_array_src[i];
dest = edgeListmem->edges_array_dest[i];
#if WEIGHTED
float weight = edgeListmem->edges_array_weight[i];
... |
atmughrabi/OpenGraph/00_graph_bench/src/structures/arrayStack.c | #pragma omp parallel for | 100 | ;
}
void arrayStackGenerateBitmap(struct ArrayStack *q)
{
uint32_t v;
uint32_t i;
<LOOP-START>for(i = q->head ; i < q->tail; i++)
{
v = q->Stack[i];
setBitAtomic(q->q_bitmap, v);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/structures/arrayStack.c | #pragma omp parallel for default(none) shared(q,b) private(v,i) | 100 | arrayStackToBitmap(struct ArrayStack *q, struct Bitmap *b)
{
uint32_t v;
uint32_t i;
<LOOP-START>for(i = q->head ; i < q->tail; i++)
{
v = q->Stack[i];
setBitAtomic(b, v);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(q,b) private(v,i)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | eof(uint32_t));
labelsTemp = (uint32_t *) my_malloc(num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < num_vertices; v++)
{
pageRanksFP[v] = FloatToFixed32SORT(pageRanks[v]);
pageRanksFPTemp[v] = 0;
labelsTemp[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel fo... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | }
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < edgeList->num_vertices; v++)
{
labelsInverse[v] = v;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | }
labelsInverse = radixSortEdgesByDegree(degrees, labelsInverse, edgeList->num_vertices);
<LOOP-START>for(v = 0; v < edgeList->num_vertices; v++)
{
labels[labelsInverse[v]] = edgeList->num_vertices - 1 - v;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | \n", Seconds(timer));
printf(" -----------------------------------------------------\n");
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.