filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | -----------------------------------\n");
// pageRankPrint(pageRanks, graph->num_vertices);
<LOOP-START>for (i = 0; i < graph->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/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | )");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices[v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024) | 100 | [v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float nodeIncomingPR = 0.0f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
nodeIncomingPR += riDividedOnDiClause[u]; // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | ces[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed64ToDouble(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(i) shared(graph,vertex_lock) | 100 | _lock_t *vertex_lock = (omp_lock_t *) my_malloc( graph->num_vertices * sizeof(omp_lock_t));
<LOOP-START>for (i = 0; i < graph->num_vertices; i++)
{
omp_init_lock(&(vertex_lock[i]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(graph,vertex_lock)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph) | 100 | );
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph) | 100 | s++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices[v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) | 100 | v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
Nodes = graph->vertices[v].outNodes;
uint32_t degree = graph->vertices[v].out_degree;
// uint32_t tid = omp_get_thread_num();
uint32_t j;
for(j = 0 ; j < (degree) ; j++)
{
uint32_t u = Nodes->edges_array_dest[j];
// omp_set_lock(&(vertex_lock[u]));
// pageRanksNext[u] += riDividedOnDiClause[v];
// omp_unset_lock((&vertex_lock[u]));
#pragma omp atomic update
pageRanksNext[u] += riDividedOnDiClause[v];
// __atomic_fetch_add(&pageRanksNext[u], riDividedOnDiClause[v], __ATOMIC_RELAXED);
// printf("tid %u degree %u edge_idx %u v %u u %u \n",tid,degree,edge_idx,v,u );
// addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | // addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed64ToDouble(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | -----------------------------------\n");
// pageRankPrint(pageRanks, graph->num_vertices);
<LOOP-START>for (i = 0; i < graph->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/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:activeVertices) | 100 | ----------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(i = 0; i < graph->num_vertices; i++)
{
workListNext[i] = 1;
activeVertices++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) shared(arguments,riDividedOnDiClause,workListCurr,workListNext,stats,graph) private(v,Nodes) reduction(+:activeVertices,error_total) schedule(dynamic, 1024) | 100 | s[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
uint32_t degree;
uint32_t j;
uint32_t u;
double error = 0;
float nodeIncomingPR = 0;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
nodeIncomingPR += riDividedOnDiClause[u]; // sum (PRi/outDegree(i))
}
float oldPageRank = stats->pageRanks[v];
float newPageRank = stats->base_pr + (stats->damp * nodeIncomingPR);
error = fabs(newPageRank - oldPageRank);
error_total += error / graph->num_vertices;
if(error >= arguments->epsilon)
{
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
#pragma omp atomic write
workListNext[u] = 1;
// uint8_t old_val = workListNext[u];
// if(!old_val){
// __sync_bool_compare_and_swap(&workListNext[u], 0, 1);
// }
}
activeVertices++;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(arguments,riDividedOnDiClause,workListCurr,workListNext,stats,graph) private(v,Nodes) reduction(+:activeVertices,error_total) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices) | 100 | ---------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
aResiduals[v] = 0.0;
workListCurr[v] = 1;
workListNext[v] = 0;
activeVertices++;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
if(graph->vertices[u].out_degree)
aResiduals[v] += 1.0f / graph->vertices[u].out_degree; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
float oldPageRank = stats->pageRanks[v];
float newPageRank = aResiduals[v] + stats->pageRanks[v];
error_total += fabs(newPageRank / graph->num_vertices - oldPageRank / graph->num_vertices);
// #pragma omp atomic write
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
float delta = stats->damp * (aResiduals[v] / degree);
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
float prevResidual = 0.0f;
prevResidual = aResiduals[u];
#pragma omp atomic update
aResiduals[u] += delta;
if ((fabs(prevResidual + delta) >= arguments->epsilon) && (prevResidual <= arguments->epsilon))
{
activeVertices++;
if(!workListNext[u])
{
// #pragma omp atomic write
workListNext[u] = 1;
}
}
}
aResiduals[v] = 0.0f;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices) | 100 | --------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
aResiduals[v] = 0.0f;
workListCurr[v] = 1;
workListNext[v] = 0;
activeVertices++;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
if(graph->vertices[u].out_degree)
aResiduals[v] += 1.0f / graph->vertices[u].out_degree; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
float nodeIncomingPR = 0.0f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
nodeIncomingPR += stats->pageRanks[u] / graph->vertices[u].out_degree;
}
float newPageRank = stats->base_pr + (stats->damp * nodeIncomingPR);
float oldPageRank = stats->pageRanks[v];
// float newPageRank = aResiduals[v]+pageRanks[v];
error_total += fabs(newPageRank / graph->num_vertices - oldPageRank / graph->num_vertices);
#pragma omp atomic write
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
float delta = stats->damp * (aResiduals[v] / degree);
for(j = 0 ; j < (degree) ; j++)
{
uint32_t u = Nodes->edges_array_dest[j];
float prevResidual = 0.0f;
prevResidual = aResiduals[u];
#pragma omp atomic update
aResiduals[u] += delta;
if ((fabs(prevResidual + delta) >= arguments->epsilon) && (prevResidual <= arguments->epsilon))
{
activeVertices++;
if(!workListNext[u])
{
workListNext[u] = 1;
}
}
}
aResiduals[v] = 0.0f;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | )");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024) | 100 | s[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float nodeIncomingPR = 0.0f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
nodeIncomingPR += riDividedOnDiClause[u]; // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | ces[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * pageRanksNext[v]);
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(i) shared(graph,vertex_lock) | 100 | lock_t *vertex_lock = (omp_lock_t *) my_malloc( graph->num_vertices * sizeof(omp_lock_t));
<LOOP-START>for (i = 0; i < graph->num_vertices; i++)
{
omp_init_lock(&(vertex_lock[i]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(graph,vertex_lock)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph) | 100 | );
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph) | 100 | s++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) | 100 | [v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
Nodes = graph->vertices[v].outNodes;
uint32_t degree = graph->vertices[v].out_degree;
// uint32_t tid = omp_get_thread_num();
uint32_t j;
for(j = 0 ; j < (degree) ; j++)
{
uint32_t u = Nodes->dest;
Nodes = Nodes->next;
// omp_set_lock(&(vertex_lock[u]));
// pageRanksNext[u] += riDividedOnDiClause[v];
// omp_unset_lock((&vertex_lock[u]));
#pragma omp atomic update
pageRanksNext[u] += riDividedOnDiClause[v];
// __atomic_fetch_add(&pageRanksNext[u], riDividedOnDiClause[v], __ATOMIC_RELAXED);
// printf("tid %u degree %u edge_idx %u v %u u %u \n",tid,degree,edge_idx,v,u );
// addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | // addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * pageRanksNext[v]);
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | -----------------------------------\n");
// pageRankPrint(pageRanks, graph->num_vertices);
<LOOP-START>for (i = 0; i < graph->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/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | )");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices[v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024) | 100 | [v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float nodeIncomingPR = 0.0f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
nodeIncomingPR += riDividedOnDiClause[u]; // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+ : error_total,activeVertices) private(v,j,u,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | ces[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed64ToDouble(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(i) shared(graph,vertex_lock) | 100 | lock_t *vertex_lock = (omp_lock_t *) my_malloc( graph->num_vertices * sizeof(omp_lock_t));
<LOOP-START>for (i = 0; i < graph->num_vertices; i++)
{
omp_init_lock(&(vertex_lock[i]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(graph,vertex_lock)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph) | 100 | );
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(pageRanksNext,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph) | 100 | s++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices[v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause,stats,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) | 100 | v].out_degree);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
Nodes = graph->vertices[v].outNodes;
uint32_t degree = graph->vertices[v].out_degree;
// uint32_t tid = omp_get_thread_num();
uint32_t j;
for(j = 0 ; j < (degree) ; j++)
{
uint32_t u = Nodes->dest;
Nodes = Nodes->next;
// omp_set_lock(&(vertex_lock[u]));
// pageRanksNext[u] += riDividedOnDiClause[v];
// omp_unset_lock((&vertex_lock[u]));
#pragma omp atomic update
pageRanksNext[u] += riDividedOnDiClause[v];
// __atomic_fetch_add(&pageRanksNext[u], riDividedOnDiClause[v], __ATOMIC_RELAXED);
// printf("tid %u degree %u edge_idx %u v %u u %u \n",tid,degree,edge_idx,v,u );
// addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v,Nodes) shared(graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | // addAtomicFloat(&pageRanksNext[u] , riDividedOnDiClause[v]);
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed64ToDouble(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | -----------------------------------\n");
// pageRankPrint(pageRanks, graph->num_vertices);
<LOOP-START>for (i = 0; i < graph->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/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:activeVertices) | 100 | ----------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(i = 0; i < graph->num_vertices; i++)
{
workListNext[i] = 1;
activeVertices++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) shared(arguments, riDividedOnDiClause, workListCurr, workListNext, stats, graph) private(v,Nodes) reduction(+:activeVertices,error_total) schedule(dynamic, 1024) | 100 | s[v].out_degree;
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
uint32_t degree;
uint32_t j;
uint32_t u;
double error = 0;
float nodeIncomingPR = 0;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
nodeIncomingPR += riDividedOnDiClause[u]; // sum (PRi/outDegree(i))
}
float oldPageRank = stats->pageRanks[v];
float newPageRank = stats->base_pr + (stats->damp * nodeIncomingPR);
error = fabs(newPageRank - oldPageRank);
error_total += error / graph->num_vertices;
if(error >= arguments->epsilon)
{
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
#pragma omp atomic write
workListNext[u] = 1;
// uint8_t old_val = workListNext[u];
// if(!old_val){
// __sync_bool_compare_and_swap(&workListNext[u], 0, 1);
// }
}
activeVertices++;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(arguments, riDividedOnDiClause, workListCurr, workListNext, stats, graph) private(v,Nodes) reduction(+:activeVertices,error_total) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices) | 100 | --------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
aResiduals[v] = 0.0;
workListCurr[v] = 1;
workListNext[v] = 0;
activeVertices++;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
if(graph->vertices[u].out_degree)
aResiduals[v] += 1.0f / graph->vertices[u].out_degree; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(Nodes,degree,v,j,u) shared(workListCurr,workListNext,aResiduals) reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
float oldPageRank = stats->pageRanks[v];
float newPageRank = aResiduals[v] + stats->pageRanks[v];
error_total += fabs(newPageRank / graph->num_vertices - oldPageRank / graph->num_vertices);
// #pragma omp atomic write
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
float delta = stats->damp * (aResiduals[v] / degree);
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
float prevResidual = 0.0f;
prevResidual = aResiduals[u];
#pragma omp atomic update
aResiduals[u] += delta;
if ((fabs(prevResidual + delta) >= arguments->epsilon) && (prevResidual <= arguments->epsilon))
{
activeVertices++;
if(!workListNext[u])
{
// #pragma omp atomic write
workListNext[u] = 1;
}
}
}
aResiduals[v] = 0.0f;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(Nodes,degree,v,j,u) shared(stats,workListCurr,workListNext,aResiduals) reduction(+:activeVertices) | 100 | --------------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
aResiduals[v] = 0.0f;
workListCurr[v] = 1;
workListNext[v] = 0;
activeVertices++;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
if(graph->vertices[u].out_degree)
aResiduals[v] += 1.0f / graph->vertices[u].out_degree; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(Nodes,degree,v,j,u) shared(stats,workListCurr,workListNext,aResiduals) reduction(+:activeVertices)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) | 100 | ++)
{
Start(timer_inner);
error_total = 0;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
float nodeIncomingPR = 0.0f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
nodeIncomingPR += stats->pageRanks[u] / graph->vertices[u].out_degree;
}
float newPageRank = stats->base_pr + (stats->damp * nodeIncomingPR);
float oldPageRank = stats->pageRanks[v];
// float newPageRank = aResiduals[v]+pageRanks[v];
error_total += fabs(newPageRank / graph->num_vertices - oldPageRank / graph->num_vertices);
#pragma omp atomic write
stats->pageRanks[v] = newPageRank;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
float delta = stats->damp * (aResiduals[v] / degree);
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->dest;
Nodes = Nodes->next;
float prevResidual = 0.0f;
prevResidual = aResiduals[u];
#pragma omp atomic update
aResiduals[u] += delta;
if ((fabs(prevResidual + delta) >= arguments->epsilon) && (prevResidual <= arguments->epsilon))
{
activeVertices++;
if(!workListNext[u])
{
workListNext[u] = 1;
}
}
}
aResiduals[v] = 0.0f;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for | 100 | f(uint32_t));
stats->dest = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vertices[v] = v;
stats->degrees[v] = graph->vertices->out_degree[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for | 100 | f(uint32_t));
stats->dest = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vertices[v] = v;
stats->degrees[v] = graph->grid->out_degree[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for | 100 | f(uint32_t));
stats->dest = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vertices[v] = v;
stats->degrees[v] = graph->vertices[v].out_degree;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for | 100 | f(uint32_t));
stats->dest = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vertices[v] = v;
stats->degrees[v] = graph->vertices[v].out_degree;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for | 100 | dgesByDegree(stats->degrees, stats->vertices, graph->num_vertices);
//initialize variables
<LOOP-START>for(v = 0 ; v < graph->num_vertices; v++)
{
stats->atomDegree[v] = graph->vertices->out_degree[v];
stats->atomChild[v] = UINT_MAX;
stats->atom[v].pair.degree = graph->vertices->out_degree[v];
stats->atom[v].pair.child = UINT_MAX;
stats->sibling[v] = UINT_MAX;
stats->dest[v] = v;
stats->weightSum[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for private(degreeTemp,edgeTemp,tempV,k,tempU) shared (bitmapNC,reachableSet,stats) | 100 |
returnReachableSetOfNodesFromDendrogram(v, stats->atom, stats->sibling, reachableSet);
// <LOOP-START>for(j = reachableSet->head ; j < reachableSet->tail; j++)
{
tempV = reachableSet->queue[j];
degreeTemp = graph->vertices->out_degree[tempV];
edgeTemp = graph->vertices->edges_idx[tempV];
for(k = edgeTemp ; k < (edgeTemp + degreeTemp) ; k++)
{
tempU = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[k]);
while(stats->dest[stats->dest[tempU]] != stats->dest[tempU])
{
// #pragma omp atomic write
stats->dest[tempU] = stats->dest[stats->dest[tempU]];
}
setBitAtomic(bitmapNC, tempU);
// edgeWeightUV++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(degreeTemp,edgeTemp,tempV,k,tempU) shared (bitmapNC,reachableSet,stats)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/incrementalAggregation.c | #pragma omp parallel for shared(Neighbors, graph, stats) reduction (+:edgeWeightUV) | 100 | }
setBitAtomic(bitmapNC, tempU);
// edgeWeightUV++;
}
}
// <LOOP-START>for(t = 0; t < graph->num_vertices ; t++)
{
if(getBit(bitmapNC, t))
{
if(!isEnArrayQueued(Neighbors, stats->dest[t]))
{
edgeWeightUV++;
enArrayQueueWithBitmapAtomic(Neighbors, stats->dest[t]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(Neighbors, graph, stats) reduction (+:edgeWeightUV)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/utils/graphStats.c | #pragma omp parallel for | 100 | ut = (uint32_t *) my_malloc(sizeof(uint32_t) * arguments->binSize);
// uint32_t i = 0;
// <LOOP-START>// for(i = 0 ; i < arguments->binSize; i++)
// {
// histogram_in[i] = 0;
// histogram_out[i] = 0;
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/utils/graphStats.c | #pragma omp parallel for | 100 | m, uint32_t binSize, uint32_t inout_degree)
// {
// uint32_t v;
// uint32_t index;
// <LOOP-START>// for(v = 0; v < graphStats->num_vertices; v++)
// {
// index = v / ((graphStats->num_vertices / binSize) + 1);
// if(inout_degree == 1)
// {
// #pragma omp atomic update
// histogram[index] += graphStats->vertices->in_degree[v];
// }
// else if(inout_degree == 2)
// {
// #pragma omp atomic update
// histogram[index] += graphStats->vertices->out_degree[v];
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/utils/graphStats.c | #pragma omp parallel for private(y) shared(SparseMatrix) | 100 | *) my_malloc(sizeof(uint32_t) * binSize * binSize);
// uint32_t x;
// uint32_t y;
// <LOOP-START>// for(x = 0; x < binSize; x++)
// {
// for(y = 0; y < binSize; y++)
// {
// SparseMatrix[(binSize * y) + x] = 0;
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for private(y) shared(SparseMatrix)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/utils/graphStats.c | #pragma omp parallel for | 100 | SparseMatrix[(binSize * y) + x] = 0;
// }
// }
// uint32_t i;
// <LOOP-START>// for(i = 0; i < graphStats->num_edges; i++)
// {
// uint32_t src;
// uint32_t dest;
// src = graphStats->sorted_edges_array->edges_array_src[i] / ((graphStats->num_vertices / binSize) + 1);
// dest = graphStats->sorted_edges_array->edges_array_dest[i] / ((graphStats->num_vertices / binSize) + 1);
// #pragma omp atomic update
// SparseMatrix[(binSize * dest) + src]++;
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/cache/cache.c | #pragma omp parallel for | 100 | ]++;
cache->access_counter++;
// if(cache->access_counter % 1000 == 0)
// {
// <LOOP-START>// for ( i = 0; i < cache->numVertices; ++i)
// {
// if(cache->vertices_base_reuse[i] != 0)
// cache->vertices_base_reuse[i] = cache->access_counter;
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/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/OpenGraphSim/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->activePartitionsMap, Partition_idx))
{
setBitAtomic(grid->activePartitionsMap, Partition_idx);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(grid,totalPartitions,row) private(i,Partition_idx)<OMP-END> |
atmughrabi/OpenGraphSim/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[Partition_idx] = 1;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(grid,totalPartitions,row) private(i,Partition_idx)<OMP-END> |
atmughrabi/OpenGraphSim/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-START>#pragma omp parallel for default(none) private(i) shared(totalPartitions,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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-END> |
atmughrabi/OpenGraphSim/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]++;
#pragma omp atomic update
grid->in_degree[dest]++;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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;
// #pragma omp parallel for default(none) private(i,src,dest) shared(j,grid) schedule(dynamic,1024) reduction(max:num_vertices)
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_dest[i];
num_vertices = maxTwoIntegers(num_vertices, maxTwoIntegers(src, dest));
}
grid->partitions[j].num_vertices = num_vertices;
grid->partitions[j].edgeList->num_vertices = num_vertices;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(totalPartitions,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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)
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_dest[i];
num_vertices = maxTwoIntegers(num_vertices, maxTwoIntegers(src, dest));
}
grid->partitions[j].num_vertices = num_vertices;
grid->partitions[j].edgeList->num_vertices = num_vertices;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,src,dest,num_vertices) shared(totalPartitions,grid) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraphSim/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_dest[i];
num_vertices = maxTwoIntegers(num_vertices, maxTwoIntegers(src, dest));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,src,dest) shared(j,grid) schedule(dynamic,1024) reduction(max:num_vertices)<OMP-END> |
atmughrabi/OpenGraphSim/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);
// __sync_fetch_and_add(&grid->in_degree[dest],1);
row = getPartitionID(num_vertices, num_partitions, src);
col = getPartitionID(num_vertices, num_partitions, dest);
Partition_idx = (row * num_partitions) + col;
// __sync_fetch_and_add(&grid->partitions[Partition_idx].num_edges,1);
#pragma omp atomic update
grid->partitions[Partition_idx].num_edges++;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,row,col,src,dest,Partition_idx) shared(num_vertices, num_partitions,edgeList,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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);
col = getPartitionID(num_vertices, num_partitions, dest);
Partition_idx = (row * num_partitions) + col;
Edge_idx = __sync_fetch_and_add(&grid->partitions[Partition_idx].num_edges, 1);
grid->partitions[Partition_idx].edgeList->edges_array_src[Edge_idx] = edgeList->edges_array_src[i];
grid->partitions[Partition_idx].edgeList->edges_array_dest[Edge_idx] = edgeList->edges_array_dest[i];
#if WEIGHTED
grid->partitions[Partition_idx].edgeList->edges_array_weight[Edge_idx] = edgeList->edges_array_weight[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Edge_idx,i,row,col,src,dest,Partition_idx) shared(num_vertices, num_partitions,edgeList,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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_vertices;
grid->partitions[i].num_edges = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i) shared(totalPartitions,grid)<OMP-END> |
atmughrabi/OpenGraphSim/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 for<OMP-END> |
atmughrabi/OpenGraphSim/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/OpenGraphSim/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/OpenGraphSim/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> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/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> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | * sizeof(uint32_t));
thresholds = (uint32_t *) my_malloc(num_buckets * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ByDegree(degreesHot[num_buckets - 1], verticesHot[num_buckets - 1], sizeHot[num_buckets - 1]);
<LOOP-START>for(v = 0; v < sizeHot[1]; v++)
{
labels[verticesHot[1][v]] = sizeHot[1] - 1 - v;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | = 0; v < sizeHot[1]; v++)
{
labels[verticesHot[1][v]] = sizeHot[1] - 1 - v;
}
<LOOP-START>for(v = 0; v < sizeHot[0]; v++)
{
labels[verticesHot[0][v]] = sizeHot[1] + (v);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/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> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | * sizeof(uint32_t));
thresholds = (uint32_t *) my_malloc(num_buckets * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/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> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,mmode) | 100 | ct EdgeList *edgeList, uint32_t mmode)
{
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];
switch(mmode)
{
case 1 :
case 3 :
{
#pragma omp atomic update
degrees[src]++;
}
break;
case 2 :
case 4 :
{
#pragma omp atomic update
degrees[dest]++;
}
break;
case 5 :
case 6 :
{
#pragma omp atomic update
degrees[dest]++;
#pragma omp atomic update
degrees[src]++;
}
break;
default :
{
#pragma omp atomic update
degrees[src]++;
}// out-degree
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,mmode)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | / VERTEX_VALUE_LUKEWARM_U32
}
cache_regions[3] = UINT32_MAX; // VERTEX_CACHE_COLD_U32
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
mask_array[i] = VERTEX_CACHE_COLD_U32;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | nds(timer));
printf(" -----------------------------------------------------\n");
}
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
edgeList->mask_array[i] = mask_array[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,lmode) | 100 | lmode)
{
uint32_t i;
uint32_t src;
uint32_t dest;
if(lmode != 10)
{
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
switch(lmode)
{
case 1 :
case 4 :
case 6 :
case 8 :
{
#pragma omp atomic update
degrees[src]++;
} // degree
break;
case 2 :
case 5 :
case 7 :
case 9 :
{
#pragma omp atomic update
degrees[dest]++;
}
break;
case 3 :
{
#pragma omp atomic update
degrees[dest]++;
#pragma omp atomic update
degrees[src]++;
}
break;
default :
{
#pragma omp atomic update
degrees[src]++;
}// out-degree
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,lmode)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for firstprivate(mt19937var) | 100 | *) my_malloc(sizeof(mt19937state));
initializeMersenneState (mt19937var, 27491095);
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = (generateRandInt(mt19937var) % edgeList->num_vertices) + omp_get_thread_num();
}<LOOP-END> <OMP-START>#pragma omp parallel for firstprivate(mt19937var)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ruct EdgeList *relabelEdgeList(struct EdgeList *edgeList, uint32_t *labels)
{
uint32_t i;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
uint32_t src;
uint32_t dest;
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
edgeList->edges_array_src[i] = labels[src];
edgeList->edges_array_dest[i] = labels[dest];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ruct EdgeList *maskEdgeList(struct EdgeList *edgeList, uint32_t *mask_array)
{
uint32_t i;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
uint32_t src;
uint32_t dest;
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
edgeList->edges_array_src[i] = src | mask_array[src];
edgeList->edges_array_dest[i] = dest | mask_array[dest];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | break;
}
fclose(pText);
edgeList = relabelEdgeList(edgeList, labels);
<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> <OMP-START>#pragma omp parallel for<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.