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);
... |
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... |
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]));
... |
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 ... |
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)... |
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_n... |
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])... |
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 ... |
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
... |
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;
doubl... |
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 ... |
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 neighb... |
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] + ... |
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 ... |
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 neigh... |
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... |
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 ... |
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
... |
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... |
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... |
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 ... |
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;
els... |
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_n... |
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]);
st... |
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 ... |
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);
... |
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... |
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]));
... |
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 ... |
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)... |
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_n... |
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]));
... |
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 ... |
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
... |
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... |
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 ... |
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 neighb... |
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] + ... |
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 ... |
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 neigh... |
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... |
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 ... |
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... |
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[... |
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++;
... |
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 atom... |
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 par... |
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 /... |
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-... |
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->activ... |
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[... |
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... |
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... |
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]++;
... |
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;
/... |
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)
... |
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_des... |
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);
/... |
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);
... |
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_ve... |
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 fo... |
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> <OM... |
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> <OM... |
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> <OM... |
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> <OM... |
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 :
... |
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 ... |
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 parall... |
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_a... |
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_a... |
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> <OM... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.