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 private(j) | 100 | lPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
// __sync_fetch_and_add(&pageRanksNext[dest],riDividedOnDiClause[src]);
// addAtomicFloat(float *num, float value)
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<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 | geRanksNext[dest] += riDividedOnDiClause[src];
}
}
}
<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(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->grid->out_degree[v])
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->grid->out_degree[v]);
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 private(i) | 100 | amEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
#pragma omp parallel for private(j)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(j) | 100 | lPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<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 | geRanksNext[dest] += riDividedOnDiClause[src];
}
}
}
<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(v) shared(graph,pageRanksNext) | 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(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->grid->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->grid->out_degree[v];
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 private(j) | 100 | treamEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t i;
// #pragma omp parallel for private(i) // iterate over partitions columnwise
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
// addAtomicFloat(&pageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(i) | 100 | (j)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
// addAtomicFloat(&pageRanksNext[dest] , riDividedOnDiClause[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) <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 | ageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}
<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(v) shared(graph,pageRanksNext) | 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(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->grid->out_degree[v])
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->grid->out_degree[v]);
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 private(j) | 100 | reamEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions columnwise
{
uint32_t i;
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
// addAtomicFloat(&pageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<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 | ageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}
<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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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 private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | ->out_degree[v];
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float nodeIncomingPR = 0.0f;
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
nodeIncomingPR += riDividedOnDiClause[u]; // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
pageRanksNext[v] = nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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(v) shared(pageRanksNext,graph) | 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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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) shared(stats,graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | >out_degree[v];
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t degree = graph->vertices->out_degree[v];
uint32_t edge_idx = graph->vertices->edges_idx[v];
// uint32_t tid = omp_get_thread_num();
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t u = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
#pragma omp atomic update
pageRanksNext[u] += riDividedOnDiClause[v];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats,graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | pdate
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;
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(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->out_degree[v])
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices->out_degree[v]);
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 private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | >out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}
<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;
// pageRanksFP[v] = FloatToFixed(nextPageRank);
pageRanksNext[v] = 0;
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(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->out_degree[v])
riDividedOnDiClause[v] = FloatToFixed32(stats->pageRanks[v] / graph->vertices->out_degree[v]);
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 private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | >out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | y[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed32ToFloat(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
// pageRanksFP[v] = FloatToFixed(nextPageRank);
pageRanksNext[v] = 0;
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(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->out_degree[v])
riDividedOnDiClause[v] = FloatToFixed16(stats->pageRanks[v] / graph->vertices->out_degree[v]);
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 private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | >out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | y[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed16ToFloat(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
// pageRanksFP[v] = FloatToFixed(nextPageRank);
pageRanksNext[v] = 0;
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(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->out_degree[v])
riDividedOnDiClause[v] = FloatToFixed8(stats->pageRanks[v] / graph->vertices->out_degree[v]);
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 private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | >out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | y[j]);
pageRanksNext[v] += riDividedOnDiClause[u];
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed8ToFloat(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
// pageRanksFP[v] = FloatToFixed(nextPageRank);
pageRanksNext[v] = 0;
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(v) shared(pageRanksNext,graph) | 100 | );
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
// pageRanksFP[v]=stats->base_prFP;
pageRanksNext[v] = 0;
}<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->out_degree[v])
{
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->vertices->out_degree[v]);
// riDividedOnDiClause[v] = DIVFixed64V1(pageRanksFP[v],UInt64ToFixed(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) schedule(dynamic, 1024) private(v) shared(stats,graph,pageRanksNext,riDividedOnDiClause) num_threads(arguments->ker_numThreads) | 100 | ;
}
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t degree = graph->vertices->out_degree[v];
uint32_t edge_idx = graph->vertices->edges_idx[v];
// uint32_t tid = omp_get_thread_num();
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t u = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
#pragma omp atomic update
pageRanksNext[u] += riDividedOnDiClause[v];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) schedule(dynamic, 1024) private(v) shared(stats,graph,pageRanksNext,riDividedOnDiClause) num_threads(arguments->ker_numThreads)<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 | update
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;
// pageRanksFP[v] = FloatToFixed(nextPageRank);
pageRanksNext[v] = 0;
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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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 private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph) | 100 | .........................................\n");
//2. Quantize riDividedOnDiClause[]
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
riDividedOnDiClause_quant[v] = quantize_32(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | v] = quantize_32(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint64_t nodeIncomingPR = 0;
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
nodeIncomingPR += riDividedOnDiClause_quant[u];
}
pageRanksNext[v] = rDivD_params.scale * nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | xt[v] = rDivD_params.scale * nodeIncomingPR;
}
//uint64_t temp_degree = 0;
<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++;
//temp_degree += vertices[v].in_degree;
}
}<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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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 private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph) | 100 | .........................................\n");
//2. Quantize riDividedOnDiClause[]
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
riDividedOnDiClause_quant[v] = quantize_16(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | v] = quantize_16(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint64_t nodeIncomingPR = 0;
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
nodeIncomingPR += riDividedOnDiClause_quant[u];
}
pageRanksNext[v] = rDivD_params.scale * nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | xt[v] = rDivD_params.scale * nodeIncomingPR;
}
//uint64_t temp_degree = 0;
<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++;
//temp_degree += vertices[v].in_degree;
}
}<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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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 private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph) | 100 | .........................................\n");
//2. Quantize riDividedOnDiClause[]
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
riDividedOnDiClause_quant[v] = quantize_8(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | [v] = quantize_8(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint64_t nodeIncomingPR = 0;
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
nodeIncomingPR += riDividedOnDiClause_quant[u];
}
//nodeIncomingPR -= (degree * rDivD_params.zero);
pageRanksNext[v] = rDivD_params.scale * nodeIncomingPR;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,j,u,degree,edge_idx) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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 | xt[v] = rDivD_params.scale * nodeIncomingPR;
}
//uint64_t temp_degree = 0;
<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++;
//temp_degree += vertices[v].in_degree;
}
}<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(v) shared(pageRanksNext,graph) | 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(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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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 private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,stats,graph) | 100 | ams.max,rDivD_params.scale,rDivD_params.zero);
//2. Quantize riDividedOnDiClause[]
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
riDividedOnDiClause_quant[v] = quantize(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(riDividedOnDiClause_quant,riDividedOnDiClause,stats,graph)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(stats,rDivD_params,riDividedOnDiClause_quant,graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | nt[v] = quantize(riDividedOnDiClause[v], rDivD_params.scale, rDivD_params.zero);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t degree = graph->vertices->out_degree[v];
uint32_t edge_idx = graph->vertices->edges_idx[v];
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t u = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
#pragma omp atomic update
pageRanksNext[u] += rDivD_params.scale * (riDividedOnDiClause_quant[v] - rDivD_params.zero);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats,rDivD_params,riDividedOnDiClause_quant,graph,pageRanksNext,riDividedOnDiClause) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, stats,pageRanksNext) reduction(+ : error_total, activeVertices) | 100 | params.scale * (riDividedOnDiClause_quant[v] - rDivD_params.zero);
}
}
<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;
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, stats,pageRanksNext) 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 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->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->vertices->out_degree[v];
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,sorted_edges_array,vertices,workListCurr,workListNext,stats,graph) private(v) reduction(+:activeVertices,error_total) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads) | 100 | ->out_degree[v];
else
riDividedOnDiClause[v] = 0.0f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(workListCurr[v])
{
uint32_t edge_idx;
uint32_t degree;
uint32_t j;
uint32_t u;
double error = 0;
float nodeIncomingPR = 0;
degree = vertices->out_degree[v]; // when directed we use inverse graph out degree means in degree
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[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;
degree = graph->vertices->out_degree[v];
edge_idx = graph->vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(graph->sorted_edges_array->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,sorted_edges_array,vertices,workListCurr,workListNext,stats,graph) private(v) reduction(+:activeVertices,error_total) schedule(dynamic, 1024) num_threads(arguments->ker_numThreads)<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(edge_idx,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++;
degree = vertices->out_degree[v]; // when directed we use inverse graph out degree means in degree
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
if(graph->vertices->out_degree[u])
aResiduals[v] += 1.0f / graph->vertices->out_degree[u]; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(edge_idx,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(edge_idx,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) num_threads(arguments->ker_numThreads) | 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;
degree = graph->vertices->out_degree[v];
float delta = stats->damp * (aResiduals[v] / degree);
edge_idx = graph->vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(graph->sorted_edges_array->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(edge_idx,degree,v,j,u) shared(stats,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) num_threads(arguments->ker_numThreads)<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(edge_idx,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++;
degree = vertices->out_degree[v]; // when directed we use inverse graph out degree means in degree
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
if(graph->vertices->out_degree[u])
aResiduals[v] += 1.0f / graph->vertices->out_degree[u]; // sum (PRi/outDegree(i))
}
aResiduals[v] = (1.0f - stats->damp) * stats->damp * aResiduals[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(edge_idx,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(edge_idx,degree,v,j,u) shared(stats,vertices,sorted_edges_array,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) num_threads(arguments->ker_numThreads) | 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;
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
nodeIncomingPR += stats->pageRanks[u] / graph->vertices->out_degree[u];
}
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;
degree = graph->vertices->out_degree[v];
float delta = stats->damp * (aResiduals[v] / degree);
edge_idx = graph->vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(graph->sorted_edges_array->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++;
aResiduals[u] += delta;
if(!workListNext[u])
{
workListNext[u] = 1;
}
}
}
aResiduals[v] = 0.0f;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(edge_idx,degree,v,j,u) shared(stats,vertices,sorted_edges_array,arguments,graph,workListCurr,workListNext,aResiduals) reduction(+:error_total,activeVertices) schedule(dynamic,1024) num_threads(arguments->ker_numThreads)<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->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 * 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->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 * 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> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.