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 def... |
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 def... |
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 def... |
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 def... |
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->dis... |
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... |
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; ... |
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,a... |
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; ... |
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)
{
... |
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 = g... |
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;
... |
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 = g... |
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];... |
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... |
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;
... |
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].outN... |
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))
... |
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].outN... |
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 = edg... |
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++;
... |
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 = edg... |
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++;
... |
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) sha... |
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) sha... |
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) sha... |
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) sha... |
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]... |
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)
... |
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 Part... |
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]... |
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)
... |
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 Part... |
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]... |
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)
... |
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);
... |
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]... |
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)
... |
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);
... |
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_... |
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_degr... |
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_... |
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_degre... |
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.0... |
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_... |
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 = ver... |
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_... |
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 =... |
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_in... |
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 ... |
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_in... |
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... |
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_in... |
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 // wil... |
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_in... |
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 =... |
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_in... |
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 ... |
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_in... |
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... |
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_in... |
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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.