filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/DFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | ptimization for DFS implentaion instead of -1 we use -out degree to for hybrid approach counter
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
stats->distances[vertex_id] = 0;
stats->parents[vertex_id] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id) shared(stats,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/DFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | cessed_nodes = 0;
stats->num_vertices = graph->num_vertices;
stats->time_total = 0.0f;
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
stats->distances[vertex_id] = 0;
stats->parents[vertex_id] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id) shared(stats,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/DFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | essed_nodes = 0;
stats->num_vertices = graph->num_vertices;
stats->time_total = 0.0f;
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
stats->distances[vertex_id] = 0;
stats->parents[vertex_id] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id) shared(stats,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/DFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | essed_nodes = 0;
stats->num_vertices = graph->num_vertices;
stats->time_total = 0.0f;
<LOOP-START>for(vertex_id = 0; vertex_id < graph->num_vertices ; vertex_id++)
{
stats->distances[vertex_id] = 0;
stats->parents[vertex_id] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id) shared(stats,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for | 100 | nt32_t));
stats->parents = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->distances[v] = UINT_MAX / 2;
stats->parents[v] = UINT_MAX;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for | 100 | nt32_t));
stats->parents = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->distances[v] = UINT_MAX / 2;
stats->parents[v] = UINT_MAX;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for | 100 | nt32_t));
stats->parents = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->distances[v] = UINT_MAX / 2;
stats->parents[v] = UINT_MAX;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for | 100 | nt32_t));
stats->parents = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->distances[v] = UINT_MAX / 2;
stats->parents[v] = UINT_MAX;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for reduction(max:maxDistance) reduction(+:numberOfDiscoverNodes) reduction(min:minDistance) | 100 | istance = UINT_MAX / 2;
uint32_t maxDistance = 0;
uint32_t numberOfDiscoverNodes = 0;
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
if(stats->distances[v] != UINT_MAX / 2)
{
numberOfDiscoverNodes++;
if(minDistance > stats->distances[v] && stats->distances[v] != 0)
minDistance = stats->distances[v];
if(maxDistance < stats->distances[v])
maxDistance = stats->distances[v];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(max:maxDistance) reduction(+:numberOfDiscoverNodes) reduction(min:minDistance)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(i) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads) | 100 | stats->processed_nodes += activeVertices;
activeVertices = 0;
uint32_t i;
<LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
// #pragma omp parallel for private(j) reduction(+ : activeVertices) schedule (dynamic,8)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
uint32_t src = partition->edgeList->edges_array_src[k];
uint32_t dest = partition->edgeList->edges_array_dest[k];
float weight = 1;
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
if(getBit(bitmapCurr, src))
{
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(j) reduction(+ : activeVertices) schedule (dynamic,8) | 100 | rtitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
uint32_t src = partition->edgeList->edges_array_src[k];
uint32_t dest = partition->edgeList->edges_array_dest[k];
float weight = 1;
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
if(getBit(bitmapCurr, src))
{
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) reduction(+ : activeVertices) schedule (dynamic,8)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(j) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads) | 100 | stats->processed_nodes += activeVertices;
activeVertices = 0;
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// #pragma omp parallel for private(i) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
uint32_t src = partition->edgeList->edges_array_src[k];
uint32_t dest = partition->edgeList->edges_array_dest[k];
float weight = 1;
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
if(getBit(bitmapCurr, src))
{
// if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
// else
// activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(i) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads) | 100 | rtitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
uint32_t src = partition->edgeList->edges_array_src[k];
uint32_t dest = partition->edgeList->edges_array_dest[k];
float weight = 1;
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
if(getBit(bitmapCurr, src))
{
// if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
// else
// activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) reduction(+ : activeVertices) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(e,src,dest) shared(graph) reduction(+:edgesPlusCounter,edgesMinusCounter) | 100 | = 0;
uint32_t edgesMinusCounter = 0;
uint32_t e;
uint32_t src;
uint32_t dest;
<LOOP-START>for(e = 0 ; e < graph->num_edges ; e++)
{
src = graph->sorted_edges_array->edges_array_src[e];
dest = graph->sorted_edges_array->edges_array_dest[e];
if(src <= dest)
{
edgesPlusCounter++;
}
else if (src > dest)
{
edgesMinusCounter++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(e,src,dest) shared(graph) reduction(+:edgesPlusCounter,edgesMinusCounter)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(e,src,dest) shared(edgesMinus_idx,edgesPlus_idx, edgesPlus,edgesMinus,graph) | 100 | tices = graph->num_vertices;
uint32_t edgesPlus_idx = 0;
uint32_t edgesMinus_idx = 0;
<LOOP-START>for(e = 0 ; e < graph->num_edges ; e++)
{
uint32_t localEdgesPlus_idx = 0;
uint32_t localEdgesMinus_idx = 0;
src = graph->sorted_edges_array->edges_array_src[e];
dest = graph->sorted_edges_array->edges_array_dest[e];
if(src <= dest)
{
localEdgesPlus_idx = __sync_fetch_and_add(&edgesPlus_idx, 1);
edgesPlus->edges_array_src[localEdgesPlus_idx] = graph->sorted_edges_array->edges_array_src[e];
edgesPlus->edges_array_dest[localEdgesPlus_idx] = graph->sorted_edges_array->edges_array_dest[e];
#if WEIGHTED
edgesPlus->edges_array_weight[localEdgesPlus_idx] = graph->sorted_edges_array->edges_array_weight[e];
}
else if (src > dest)
{
localEdgesMinus_idx = __sync_fetch_and_add(&edgesMinus_idx, 1);
edgesMinus->edges_array_src[localEdgesMinus_idx] = graph->sorted_edges_array->edges_array_src[e];
edgesMinus->edges_array_dest[localEdgesMinus_idx] = graph->sorted_edges_array->edges_array_dest[e];
#if WEIGHTED
edgesMinus->edges_array_weight[localEdgesMinus_idx] = graph->sorted_edges_array->edges_array_weight[e];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(e,src,dest) shared(edgesMinus_idx,edgesPlus_idx, edgesPlus,edgesMinus,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(v) shared(vertices,sorted_edges_array,graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | ifdef SNIPER_HARNESS
int iteration = iter;
SimMarker(1, iteration);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t minDistance = UINT_MAX / 2;
uint32_t minParent = UINT_MAX;
uint32_t degree;
uint32_t j, u, w;
uint32_t edge_idx;
if(getBit(bitmapCurr, v))
{
degree = vertices->out_degree[v];
edge_idx = vertices->edges_idx[v];
// printf("degree %u arguments->source %u \n",degree,v );
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array->edges_array_dest[j]);
w = 1;
#if WEIGHTED
w = sorted_edges_array->edges_array_weight[j];
if (minDistance > (stats->distances[u] + w))
{
minDistance = (stats->distances[u] + w);
minParent = u;
}
}
if(bellmanFordAtomicMin(&(stats->distances[v]), minDistance))
{
stats->parents[v] = minParent;
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]);
if(!getBit(bitmapNext, u))
{
activeVertices++;
setBitAtomic(bitmapNext, u);
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(vertices,sorted_edges_array,graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | ifdef SNIPER_HARNESS
int iteration = iter;
SimMarker(1, iteration);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(getBit(bitmapCurr, 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 src = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_src[j]);
uint32_t dest = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
float weight = 1;
#if WEIGHTED
weight = graph->sorted_edges_array->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for | 100 | ----------------------------------------\n");
Start(timer);
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vertices[v] = v;
degrees[v] = graph->vertices->out_degree[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(v,n) shared(vertices,graphPlus,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | ifdef SNIPER_HARNESS
int iteration = iter;
SimMarker(1, iteration);
#endif
<LOOP-START>for(n = 0; n < graphPlus->num_vertices; n++)
{
v = vertices[n];
if(getBit(bitmapCurr, v))
{
uint32_t degree = graphPlus->vertices->out_degree[v];
uint32_t edge_idx = graphPlus->vertices->edges_idx[v];
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t src = EXTRACT_VALUE(graphPlus->sorted_edges_array->edges_array_src[j]);
uint32_t dest = EXTRACT_VALUE(graphPlus->sorted_edges_array->edges_array_dest[j]);
float weight = 1;
#if WEIGHTED
weight = graphPlus->sorted_edges_array->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,n) shared(vertices,graphPlus,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(v,n) shared(vertices,graphMinus,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | ef SNIPER_HARNESS
SimMarker(2, iteration);
SimMarker(3, iteration);
#endif
<LOOP-START>for(n = 0; n < graphMinus->num_vertices; n++)
{
v = vertices[n];
if(getBit(bitmapCurr, v))
{
uint32_t degree = graphMinus->vertices->out_degree[v];
uint32_t edge_idx = graphMinus->vertices->edges_idx[v];
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t src = EXTRACT_VALUE(graphMinus->sorted_edges_array->edges_array_src[j]);
uint32_t dest = EXTRACT_VALUE(graphMinus->sorted_edges_array->edges_array_dest[j]);
float weight = 1;
#if WEIGHTED
weight = graphMinus->sorted_edges_array->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,n) shared(vertices,graphMinus,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(nodes,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | imer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t minDistance = UINT_MAX / 2;
uint32_t degree;
uint32_t j, u, w;
uint32_t minParent = UINT_MAX;
if(getBit(bitmapCurr, v))
{
#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;
// printf("degree %u arguments->source %u \n",degree,v );
for(j = 0 ; j < (degree) ; j++)
{
u = nodes->edges_array_dest[j];
w = 1;
#if WEIGHTED
w = nodes->edges_array_weight[j];
// printf("w %u \n",w );
if (minDistance > (stats->distances[u] + w))
{
minDistance = (stats->distances[u] + w);
minParent = u;
}
}
if(bellmanFordAtomicMin(&(stats->distances[v]), minDistance))
{
// stats->distances[v] = minDistance;
stats->parents[v] = minParent;
nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = nodes->edges_array_dest[j];
w = 1;
#if WEIGHTED
w = nodes->edges_array_weight[j];
if(!getBit(bitmapNext, u))
{
activeVertices++;
setBitAtomic(bitmapNext, u);
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(nodes,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(nodes,degree,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | mer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(getBit(bitmapCurr, v))
{
degree = graph->vertices[v].out_degree;
nodes = graph->vertices[v].outNodes;
uint32_t j;
for(j = 0 ; j < (degree) ; j++)
{
uint32_t src = nodes->edges_array_src[j];
uint32_t dest = nodes->edges_array_dest[j];
float weight = 1;
#if WEIGHTED
weight = nodes->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(src, dest, weight, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(src, dest, weight, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(nodes,degree,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(nodes,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | mer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t minDistance = UINT_MAX / 2;
uint32_t degree;
uint32_t j, u, w;
if(getBit(bitmapCurr, v))
{
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = nodes->dest;
w = 1;
#if WEIGHTED
w = nodes->weight;
nodes = nodes->next;
if (minDistance > (stats->distances[u] + w))
{
minDistance = (stats->distances[u] + w);
}
}
if(bellmanFordAtomicMin(&(stats->distances[v]), minDistance))
{
stats->parents[v] = minDistance;
nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = nodes->dest;
w = 1;
#if WEIGHTED
w = nodes->weight;
nodes = nodes->next;
if(!getBit(bitmapNext, u))
{
activeVertices++;
setBitAtomic(bitmapNext, u);
}
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(nodes,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/bellmanFord.c | #pragma omp parallel for private(nodes,degree,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128) | 100 | mer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(getBit(bitmapCurr, v))
{
degree = graph->vertices[v].out_degree;
nodes = graph->vertices[v].outNodes;
uint32_t j;
for(j = 0 ; j < (degree) ; j++)
{
uint32_t u = nodes->dest;
uint32_t w = 1;
#if WEIGHTED
w = nodes->weight;
nodes = nodes->next;
if(arguments->algo_numThreads == 1)
activeVertices += bellmanFordRelax(v, u, w, stats, bitmapNext);
else
activeVertices += bellmanFordAtomicRelax(v, u, w, stats, bitmapNext);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(nodes,degree,v) shared(graph,stats,bitmapNext,bitmapCurr) reduction(+ : activeVertices) schedule (dynamic,128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | al = 0.0f;
stats->counts = (uint64_t *) my_malloc(graph->num_vertices * sizeof(uint64_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->counts[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | al = 0.0f;
stats->counts = (uint64_t *) my_malloc(graph->num_vertices * sizeof(uint64_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->counts[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | al = 0.0f;
stats->counts = (uint64_t *) my_malloc(graph->num_vertices * sizeof(uint64_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->counts[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | al = 0.0f;
stats->counts = (uint64_t *) my_malloc(graph->num_vertices * sizeof(uint64_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->counts[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) schedule(dynamic, 128) | 100 | loc(sizeof(struct Timer));
Start(timer);
#ifdef SNIPER_HARNESS
SimRoiStart();
#endif
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t degree_u = graph->vertices->out_degree[u];
uint32_t edge_idx_u = graph->vertices->edges_idx[u];
uint32_t v;
for(v = edge_idx_u; v < (edge_idx_u + degree_u) ; v++)
{
uint32_t node_v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[v]);
uint32_t degree_v = graph->vertices->out_degree[node_v];
uint32_t edge_idx_v = graph->vertices->edges_idx[node_v];
uint32_t w;
uint32_t degree_iter = graph->vertices->out_degree[u];
uint32_t edge_idx_iter = graph->vertices->edges_idx[u];
uint32_t iter;
for(w = edge_idx_v; w < (edge_idx_v + degree_v) ; w++)
{
uint32_t node_w = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[w]);
uint32_t node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[edge_idx_iter]);
for(iter = edge_idx_iter; iter < (edge_idx_iter + degree_iter) ; iter++)
{
node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[iter]);
if(node_iter == node_w)
// #pragma omp atomic update
stats->counts[u]++;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(stats) schedule(dynamic, 128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats) | 100 | IPER_HARNESS
SimRoiEnd();
#endif
Stop(timer);
stats->time_total = Seconds(timer);
<LOOP-START>for(u = 0; u < stats->num_vertices; u++)
{
counts += stats->counts[u];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128) | 100 | loc(sizeof(struct Timer));
Start(timer);
#ifdef SNIPER_HARNESS
SimRoiStart();
#endif
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t degree_u = graph->vertices->out_degree[u];
uint32_t edge_idx_u = graph->vertices->edges_idx[u];
uint32_t v;
steps++;
for(v = edge_idx_u; v < (edge_idx_u + degree_u) ; v++)
{
uint32_t node_v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[v]);
uint32_t degree_v = graph->vertices->out_degree[node_v];
if(node_v > u)
break;
uint32_t edge_idx_v = graph->vertices->edges_idx[node_v];
uint32_t w;
uint32_t degree_iter = graph->vertices->out_degree[u];
uint32_t edge_idx_iter = graph->vertices->edges_idx[u];
uint32_t iter;
for(w = edge_idx_v; w < (edge_idx_v + degree_v) ; w++)
{
uint32_t node_w = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[w]);
if(node_w > node_v)
break;
uint32_t node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[edge_idx_iter]);
for(iter = edge_idx_iter; iter < (edge_idx_iter + degree_iter) ; iter++)
{
node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[iter]);
if(node_iter >= node_w)
break;
}
if(node_w == node_iter)
{
counts++;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) schedule(dynamic, 128) | 100 | loc(sizeof(struct Timer));
Start(timer);
#ifdef SNIPER_HARNESS
SimRoiStart();
#endif
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t degree_u = graph->vertices->out_degree[u];
uint32_t edge_idx_u = graph->vertices->edges_idx[u];
uint32_t v;
for(v = edge_idx_u; v < (edge_idx_u + degree_u) ; v++)
{
uint32_t node_v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[v]);
if(node_v > u)
break;
uint32_t degree_v = graph->vertices->out_degree[node_v];
uint32_t edge_idx_v = graph->vertices->edges_idx[node_v];
uint32_t w;
uint32_t degree_iter = graph->vertices->out_degree[u];
uint32_t edge_idx_iter = graph->vertices->edges_idx[u];
uint32_t iter;
for(w = edge_idx_v; w < (edge_idx_v + degree_v) ; w++)
{
uint32_t node_w = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[w]);
if(node_w > node_v)
break;
uint32_t node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[edge_idx_iter]);
for(iter = edge_idx_iter; iter < (edge_idx_iter + degree_iter) ; iter++)
{
node_iter = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[iter]);
if(node_iter >= node_w)
break;
}
if(node_w == node_iter)
{
#pragma omp atomic update
stats->counts[node_w]++;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(stats) schedule(dynamic, 128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats) | 100 | IPER_HARNESS
SimRoiEnd();
#endif
Stop(timer);
stats->time_total = Seconds(timer);
<LOOP-START>for(u = 0; u < stats->num_vertices; u++)
{
counts += stats->counts[u];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128) | 100 | loc(sizeof(struct Timer));
Start(timer);
#ifdef SNIPER_HARNESS
SimRoiStart();
#endif
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t degree_u = graph->vertices->out_degree[u];
uint32_t edge_idx_u = graph->vertices->edges_idx[u];
uint32_t v;
steps++;
for(v = edge_idx_u; v < (edge_idx_u + degree_u) ; v++)
{
uint32_t node_v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[v]);
if(node_v > u)
break;
counts += countIntersectionsBinarySearch(u, node_v, graph);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | f(float));
stats->vector_input = (float *) my_malloc(graph->num_vertices * sizeof(float));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->vector_output[v] = 0.0f;
stats->vector_input[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | f(float));
stats->vector_input = (float *) my_malloc(graph->num_vertices * sizeof(float));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->vector_output[v] = 0.0f;
stats->vector_input[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | (float));
stats->vector_input = (float *) my_malloc(graph->num_vertices * sizeof(float));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->vector_output[v] = 0.0f;
stats->vector_input[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | f(float));
stats->vector_input = (float *) my_malloc(graph->num_vertices * sizeof(float));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->vector_output[v] = 0.0f;
stats->vector_input[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
stats->vector_input[v] = (1.0f / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | >iterations; stats->iterations++)
{
Start(timer_inner);
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
float weight = 0.0001f;
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];
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
// #pragma omp atomic update
// __sync_fetch_and_add(&stats->vector_output[dest],(weight * stats->vector_input[src]));
// addAtomicFloat(&stats->vector_output[dest], (weight * stats->vector_input[src])
// #pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 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;
float weight = 0.0001f;
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];
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
// #pragma omp atomic update
// __sync_fetch_and_add(&stats->vector_output[dest],(weight * stats->vector_input[src]));
// addAtomicFloat(&stats->vector_output[dest], (weight * stats->vector_input[src])
// #pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
stats->vector_input[v] = (1.0f / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ts->iterations; stats->iterations++)
{
Start(timer_inner);
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
float weight = 0.0001f;
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];
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
// #pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | rtitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
float weight = 0.0001f;
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];
#if WEIGHTED
weight = partition->edgeList->edges_array_weight[k];
// #pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
stats->vector_input[v] = (1.0f / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | >iterations; stats->iterations++)
{
Start(timer_inner);
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
uint64_t weight = DoubleToFixed64(0.0001f);
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];
#if WEIGHTED
weight = DoubleToFixed64(partition->edgeList->edges_array_weight[k]);
// #pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 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;
uint64_t weight = DoubleToFixed64(0.0001f);
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];
#if WEIGHTED
weight = DoubleToFixed64(partition->edgeList->edges_array_weight[k]);
// #pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | rtices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
stats->vector_input[v] = (1.0f / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | / graph->grid->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ts->iterations; stats->iterations++)
{
Start(timer_inner);
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
uint64_t weight = DoubleToFixed64(0.0001f);
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];
#if WEIGHTED
weight = DoubleToFixed64(partition->edgeList->edges_array_weight[k]);
// #pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | rtitions; ++j) // iterate over partitions colwise
{
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
uint64_t weight = DoubleToFixed64(0.0001f);
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];
#if WEIGHTED
weight = DoubleToFixed64(partition->edgeList->edges_array_weight[k]);
// #pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | rtices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices->out_degree[v])
stats->vector_input[v] = (1.0f / graph->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024) | 100 | def SNIPER_HARNESS
int iter = stats->iterations;
SimMarker(1, iter);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src ;
uint32_t dest = v;
float weight = 0.0001f;
degree = vertices->out_degree[dest];
edge_idx = vertices->edges_idx[dest];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
src = EXTRACT_VALUE(sorted_edges_array[j]);
#if WEIGHTED
weight = edges_array_weight[j];
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_input[src]), 'r', src, EXTRACT_MASK(sorted_edges_array[j]));
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_output[dest]), 'r', dest, graph->sorted_edges_array->mask_array[dest]);
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_output[dest]), 'w', dest, graph->sorted_edges_array->mask_array[dest]);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | onds(timer_inner));
}// end iteration loop
#ifdef SNIPER_HARNESS
SimRoiEnd();
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices->out_degree[v])
stats->vector_input[v] = (1.0f / graph->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024) | 100 | ef SNIPER_HARNESS
int iter = stats->iterations;
SimMarker(1, iter);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
float weight = 0.0001f;
degree = vertices->out_degree[src];
edge_idx = vertices->edges_idx[src];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
dest = EXTRACT_VALUE(sorted_edges_array[j]);
#if WEIGHTED
weight = edges_array_weight[j];
#pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | nds(timer_inner));
}// end iteration loop
#ifdef SNIPER_HARNESS
SimRoiEnd();
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 |
setDoubleTaggedCacheThresholdDegreeAvg(stats->cache, graph->vertices->out_degree);
#endif
<LOOP-START>for (w = 0; w < graph->num_edges ; ++w)
{
#if WEIGHTED
edges_array_weight_fixedPoint[w] = FloatToFixed32(edges_array_weight[w]);
#else
edges_array_weight_fixedPoint[w] = FloatToFixed32(0.0001f);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices->out_degree[v])
stats->vector_input[v] = (1.0f / graph->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | h->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = FloatToFixed32(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024) | 100 | def SNIPER_HARNESS
int iter = stats->iterations;
SimMarker(1, iter);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src;
uint32_t dest = v;
float weight = FloatToFixed32(0.0001f);
degree = vertices->out_degree[dest];
edge_idx = vertices->edges_idx[dest];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
src = EXTRACT_VALUE(sorted_edges_array[j]);
#if WEIGHTED
weight = edges_array_weight_fixedPoint[j];
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_input[src]), 'r', src, EXTRACT_MASK(sorted_edges_array[j]));
vector_output[dest] += MULFixed32V1(weight, vector_input[src]); // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_output[dest]), 'r', dest, graph->sorted_edges_array->mask_array[dest]);
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->vector_output[dest]), 'w', dest, graph->sorted_edges_array->mask_array[dest]);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | onds(timer_inner));
}// end iteration loop
#ifdef SNIPER_HARNESS
SimRoiEnd();
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed32ToFloat(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ertices; v++)
{
stats->vector_output[v] = Fixed32ToFloat(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices->out_degree[v])
stats->vector_input[v] = (1.0f / graph->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | aph->vertices->out_degree[v]);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024) | 100 | ef SNIPER_HARNESS
int iter = stats->iterations;
SimMarker(1, iter);
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
uint64_t weight = DoubleToFixed64(0.0001f);
degree = vertices->out_degree[src];
edge_idx = vertices->edges_idx[src];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
dest = EXTRACT_VALUE(sorted_edges_array[j]);
#if WEIGHTED
weight = DoubleToFixed64(edges_array_weight[j]);
#pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | onds(timer_inner));
}// end iteration loop
#ifdef SNIPER_HARNESS
SimRoiEnd();
#endif
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | rtices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src;
uint32_t dest = v;
float weight = 0.0001f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[dest].inNodes;
degree = graph->vertices[dest].in_degree;
#else
Nodes = graph->vertices[dest].outNodes;
degree = graph->vertices[dest].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
src = Nodes->edges_array_dest[j];
#if WEIGHTED
weight = Nodes->edges_array_weight[j];
stats->vector_output[dest] += (weight * stats->vector_input[src]); // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
float weight = 0.0001f;
Nodes = graph->vertices[src].outNodes;
degree = graph->vertices[src].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
dest = Nodes->edges_array_dest[j];
#if WEIGHTED
weight = Nodes->edges_array_weight[j];
#pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | raph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src;
uint32_t dest = v;
uint64_t weight = DoubleToFixed64(0.0001f);
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[dest].inNodes;
degree = graph->vertices[dest].in_degree;
#else
Nodes = graph->vertices[dest].outNodes;
degree = graph->vertices[dest].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
src = Nodes->edges_array_dest[j];
#if WEIGHTED
weight = DoubleToFixed64(Nodes->edges_array_weight[j]);
vector_output[dest] += MULFixed64V1(weight, vector_input[src]); // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | tices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | raph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
uint64_t weight = DoubleToFixed64(0.0001f);
Nodes = graph->vertices[src].outNodes;
degree = graph->vertices[src].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
dest = Nodes->edges_array_dest[j];
#if WEIGHTED
weight = DoubleToFixed64(Nodes->edges_array_weight[j]);
#pragma omp atomic update
vector_output[dest] += MULFixed64V1(weight, vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | rtices; v++)
{
stats->vector_output[v] = Fixed64ToDouble(vector_output[v]);
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src;
uint32_t dest = v;
float weight = 0.0001f;
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[dest].inNodes;
degree = graph->vertices[dest].in_degree;
#else
Nodes = graph->vertices[dest].outNodes;
degree = graph->vertices[dest].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
src = Nodes->dest;
#if WEIGHTED
weight = Nodes->weight;
Nodes = Nodes->next;
stats->vector_output[dest] += (weight * stats->vector_input[src]); // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
float weight = 0.0001f;
Nodes = graph->vertices[src].outNodes;
degree = graph->vertices[src].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
dest = Nodes->dest;
#if WEIGHTED
weight = Nodes->weight;
Nodes = Nodes->next;
#pragma omp atomic update
stats->vector_output[dest] += (weight * stats->vector_input[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for reduction(+:sum) | 100 | ("| %-21u | %-27f | \n", stats->iterations, Seconds(timer_inner));
}// end iteration loop
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
sum += ((int)(stats->vector_output[v] * 100 + .5) / 100.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | ---------------------------------\n");
//assume any vector input for benchamrking purpose.
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->vertices[v].out_degree)
stats->vector_input[v] = (1.0f / graph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | raph->vertices[v].out_degree);
else
stats->vector_input[v] = 0.001f;
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
vector_output[v] = 0;
vector_input[v] = DoubleToFixed64(stats->vector_input[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024) | 100 | iterations < arguments->iterations; stats->iterations++)
{
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src;
uint32_t dest = v;
uint64_t weight = DoubleToFixed64(0.0001f);
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[dest].inNodes;
degree = graph->vertices[dest].in_degree;
#else
Nodes = graph->vertices[dest].outNodes;
degree = graph->vertices[dest].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
src = Nodes->dest;
#if WEIGHTED
weight = DoubleToFixed64(Nodes->weight);
Nodes = Nodes->next;
vector_output[dest] += MULFixed64V1(weight, vector_input[src]); // stats->pageRanks[v]/graph->vertices[v].out_degree;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 1024)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.