filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | \n", Seconds(timer));
printf(" -----------------------------------------------------\n");
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | \n", Seconds(timer));
printf(" -----------------------------------------------------\n");
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | * sizeof(uint32_t));
thresholds = (uint32_t *) my_malloc(num_buckets * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ByDegree(degreesHot[num_buckets - 1], verticesHot[num_buckets - 1], sizeHot[num_buckets - 1]);
<LOOP-START>for(v = 0; v < sizeHot[1]; v++)
{
labels[verticesHot[1][v]] = sizeHot[1] - 1 - v;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | = 0; v < sizeHot[1]; v++)
{
labels[verticesHot[1][v]] = sizeHot[1] - 1 - v;
}
<LOOP-START>for(v = 0; v < sizeHot[0]; v++)
{
labels[verticesHot[0][v]] = sizeHot[1] + (v);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | \n", Seconds(timer));
printf(" -----------------------------------------------------\n");
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | * sizeof(uint32_t));
thresholds = (uint32_t *) my_malloc(num_buckets * sizeof(uint32_t));
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | \n", Seconds(timer));
printf(" -----------------------------------------------------\n");
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,mmode) | 100 | ct EdgeList *edgeList, uint32_t mmode)
{
uint32_t i;
uint32_t src;
uint32_t dest;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
switch(mmode)
{
case 1 :
case 3 :
... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | / VERTEX_VALUE_LUKEWARM_U32
}
cache_regions[3] = UINT32_MAX; // VERTEX_CACHE_COLD_U32
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
mask_array[i] = VERTEX_CACHE_COLD_U32;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | nds(timer));
printf(" -----------------------------------------------------\n");
}
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
edgeList->mask_array[i] = mask_array[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for default(none) private(i,src,dest) shared(edgeList,degrees,lmode) | 100 | lmode)
{
uint32_t i;
uint32_t src;
uint32_t dest;
if(lmode != 10)
{
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
switch(lmode)
{
case ... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for firstprivate(mt19937var) | 100 | *) my_malloc(sizeof(mt19937state));
initializeMersenneState (mt19937var, 27491095);
<LOOP-START>for (i = 0; i < edgeList->num_vertices; ++i)
{
degrees[i] = (generateRandInt(mt19937var) % edgeList->num_vertices) + omp_get_thread_num();
}<LOOP-END> <OMP-START>#pragma omp parall... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ruct EdgeList *relabelEdgeList(struct EdgeList *edgeList, uint32_t *labels)
{
uint32_t i;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
uint32_t src;
uint32_t dest;
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
edgeList->edges_a... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | ruct EdgeList *maskEdgeList(struct EdgeList *edgeList, uint32_t *mask_array)
{
uint32_t i;
<LOOP-START>for(i = 0; i < edgeList->num_edges; i++)
{
uint32_t src;
uint32_t dest;
src = edgeList->edges_array_src[i];
dest = edgeList->edges_array_dest[i];
edgeList->edges_a... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/reorder.c | #pragma omp parallel for | 100 | break;
}
fclose(pText);
edgeList = relabelEdgeList(edgeList, labels);
<LOOP-START>for (v = 0; v < edgeList->num_vertices; ++v)
{
edgeList->label_array[v] = labels[edgeList->label_array[v]];
edgeList->inverse_label_array[edgeList->label_array[v]] = v;
}<LOOP-END> <OM... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/countsort.c | #pragma omp parallel for | 100 | _weight[i];
#endif
vertex_count[(t_id * num_vertices) + key]++;
}
}
<LOOP-START>for(i = 0; i < num_edges; i++)
{
edgeList->edges_array_dest[i] = sorted_edges_array->edges_array_dest[i];
edgeList->edges_array_src[i] = sorted_edges_array->edges_array_src[i];
#if WEIGHTE... |
atmughrabi/OpenGraph/00_graph_bench/src/preprocess/countsort.c | #pragma omp parallel for | 100 | weight[i];
#endif
vertex_count[(t_id * num_vertices) + key]++;
}
}
<LOOP-START>for(i = 0; i < num_edges; i++)
{
edgeList->edges_array_dest[i] = sorted_edges_array->edges_array_dest[i];
edgeList->edges_array_src[i] = sorted_edges_array->edges_array_src[i];
#if WEIGHTE... |
atmughrabi/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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 | 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 minParent = UINT_MAX;
uint32_t degree;
uint32_t j, u, w;
... |
atmughrabi/OpenGraph/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 | imer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<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/OpenGraph/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/OpenGraph/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 | imer_inner);
stats->processed_nodes += activeVertices;
activeVertices = 0;
<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/OpenGraph/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 | omicRelax(src, dest, weight, stats, bitmapNext);
}
}
}
<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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) schedule(dynamic, 128) | 100 | );
struct Timer *timer = (struct Timer *) malloc(sizeof(struct Timer));
Start(timer);
<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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats) | 100 | }
}
}
}
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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128) | 100 | );
struct Timer *timer = (struct Timer *) malloc(sizeof(struct Timer));
Start(timer);
<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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) schedule(dynamic, 128) | 100 | );
struct Timer *timer = (struct Timer *) malloc(sizeof(struct Timer));
Start(timer);
<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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for default(none) reduction (+ : counts) private(u) shared(stats) | 100 | }
}
}
}
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/OpenGraph/00_graph_bench/src/algorithms/openmp/triangleCount.c | #pragma omp parallel for shared(stats) reduction(+:counts) schedule(dynamic, 128) | 100 | );
struct Timer *timer = (struct Timer *) malloc(sizeof(struct Timer));
Start(timer);
<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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) 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;
degree = vertices->out_degr... |
atmughrabi/OpenGraph/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/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) 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;
degree = vertices->out_degre... |
atmughrabi/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for | 100 | WEIGHTED
edges_array_weight = graph->sorted_edges_array->edges_array_weight;
#endif
#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/OpenGraph/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/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) 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 = FloatToFixed32(0.0001f);
degree = ver... |
atmughrabi/OpenGraph/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] = Fixed32ToFloat(vector_output[v]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/00_graph_bench/src/algorithms/openmp/SPMV.c | #pragma omp parallel for private(v,degree,edge_idx) 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);
degree =... |
atmughrabi/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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/OpenGraph/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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.