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/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 | 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->dest;
#if WEIGHTED
weight = DoubleToFixed64(Nodes->weight);
Nodes = Nodes->next;
#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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));
stats->labels = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->components[v] = v;
stats->labels[v] = 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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));
stats->labels = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->components[v] = v;
stats->labels[v] = 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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));
stats->labels = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->components[v] = v;
stats->labels[v] = 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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));
stats->labels = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->components[v] = v;
stats->labels[v] = 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/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | ;
}
}
void compressNodes(uint32_t num_vertices, uint32_t *components)
{
uint32_t n;
<LOOP-START>for (n = 0; n < num_vertices; n++)
{
while (components[n] != components[components[n]])
{
components[n] = components[components[n]];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 512) | 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;
degree = graph->vertices->out_degree[src];
edge_idx = graph->vertices->edges_idx[src];
// #ifdef CACHE_HARNESS
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (graph->vertices->out_degree[src]), 'r', src, graph->vertices->out_degree[src]);
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (graph->vertices->edges_idx[src]), 'r', src, graph->vertices->edges_idx[src]);
//
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
dest = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
uint32_t comp_src = stats->components[src];
uint32_t comp_dest = stats->components[dest];
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->components[src]), 'r', src, graph->sorted_edges_array->mask_array[src]);
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->components[dest]), 'r', dest, EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]));
if(comp_src == comp_dest)
continue;
uint32_t comp_high = comp_src > comp_dest ? comp_src : comp_dest;
uint32_t comp_low = comp_src + (comp_dest - comp_high);
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->components[comp_high]), 'r', comp_high, graph->sorted_edges_array->mask_array[comp_high]);
if(comp_high == stats->components[comp_high])
{
change = 1;
stats->components[comp_high] = comp_low;
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->components[comp_high]), 'w', comp_high, graph->sorted_edges_array->mask_array[comp_high]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | t(timer);
for(r = 0; r < stats->neighbor_rounds; r++)
{
Start(timer_inner);
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
uint32_t degree_out = graph->vertices->out_degree[u];
uint32_t edge_idx_out = graph->vertices->edges_idx[u];
for(j = (edge_idx_out + r) ; j < (edge_idx_out + degree_out) ; j++)
{
v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
linkNodes(u, v, stats->components);
break;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | -----------------------------------------------------\n");
Start(timer_inner);
#if DIRECTED
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
uint32_t degree_out;
uint32_t degree_in;
uint32_t edge_idx_out;
uint32_t edge_idx_in;
if(stats->components[u] == sampleComp)
continue;
degree_out = graph->vertices->out_degree[u];
edge_idx_out = graph->vertices->edges_idx[u];
for(j = (edge_idx_out + stats->neighbor_rounds) ; j < (edge_idx_out + degree_out) ; j++)
{
v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
linkNodes(u, v, stats->components);
}
degree_in = graph->inverse_vertices->out_degree[u];
edge_idx_in = graph->inverse_vertices->edges_idx[u];
for(j = (edge_idx_in) ; j < (edge_idx_in + degree_in) ; j++)
{
v = EXTRACT_VALUE(graph->inverse_sorted_edges_array->edges_array_dest[j]);
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | y->edges_array_dest[j]);
linkNodes(u, v, stats->components);
}
}
#else
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
uint32_t degree_out;
uint32_t edge_idx_out;
if(stats->components[u] == sampleComp)
continue;
degree_out = graph->vertices->out_degree[u];
edge_idx_out = graph->vertices->edges_idx[u];
for(j = (edge_idx_out + stats->neighbor_rounds) ; j < (edge_idx_out + degree_out) ; j++)
{
v = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 512) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
degree = graph->vertices->out_degree[src];
edge_idx = graph->vertices->edges_idx[src];
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
dest = EXTRACT_VALUE(graph->sorted_edges_array->edges_array_dest[j]);
if(atomicMin(&(stats->components[dest]), stats->components[src]))
{
setBitAtomic(bitmapNext, dest);
}
if(atomicMin(&(stats->components[src]), stats->components[dest]))
{
setBitAtomic(bitmapNext, src);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,edge_idx) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for reduction (+:change) | 100 | }
}
// compressNodes( stats->num_vertices, stats->components);
<LOOP-START>for(v = 0 ; v < ((bitmapNext->size + kBitsPerWord - 1) / kBitsPerWord); v++)
{
change += bitmapNext->bitarray[v];
bitmapNext->bitarray[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction (+:change)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
uint32_t comp_src = stats->components[src];
uint32_t comp_dest = stats->components[dest];
if(comp_src != comp_dest)
{
uint32_t comp_high = comp_src > comp_dest ? comp_src : comp_dest;
uint32_t comp_low = comp_src + (comp_dest - comp_high);
if(comp_high == stats->components[comp_high])
{
change = 1;
stats->components[comp_high] = comp_low;
}
}
}
}
}<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/connectedComponents.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
uint32_t comp_src = stats->components[src];
uint32_t comp_dest = stats->components[dest];
if(comp_src != comp_dest)
{
uint32_t comp_high = comp_src > comp_dest ? comp_src : comp_dest;
uint32_t comp_low = comp_src + (comp_dest - comp_high);
if(comp_high == stats->components[comp_high])
{
change = 1;
stats->components[comp_high] = comp_low;
}
}
}
}<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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(graph,neighbor) | 100 | );
struct Bitmap *linked = newBitmap(graph->num_vertices);
stats->neighbor_rounds = 2;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
neighbor[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,neighbor)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | t(timer);
for(r = 0; r < stats->neighbor_rounds; r++)
{
Start(timer_inner);
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(neighbor[src] >= r && !getBit(linked, src))
{
linkNodes(src, dest, stats->components);
setBit(linked, src);
}
else
{
neighbor[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/connectedComponents.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(neighbor[src] >= r && !getBit(linked, src))
{
linkNodes(src, dest, stats->components);
setBit(linked, src);
}
else
{
neighbor[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/connectedComponents.c | #pragma omp parallel for default(none) private(v) shared(stats,neighbor) | 100 | Stop(timer_inner);
printf("| %-21u | %-27f | \n", r, Seconds(timer_inner));
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
neighbor[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats,neighbor)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | -----------------------------------------------------\n");
Start(timer_inner);
#if DIRECTED
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(stats->components[src] != sampleComp)
{
if(neighbor[src] >= stats->neighbor_rounds)
{
linkNodes(src, dest, stats->components);
}
else
{
neighbor[src]++;
}
}
if(stats->components[dest] != sampleComp)
{
linkNodes(dest, src, stats->components);
}
}
}
}<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/connectedComponents.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ts->algo_numThreads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(stats->components[src] != sampleComp)
{
if(neighbor[src] >= stats->neighbor_rounds)
{
linkNodes(src, dest, stats->components);
}
else
{
neighbor[src]++;
}
}
if(stats->components[dest] != sampleComp)
{
linkNodes(dest, src, stats->components);
}
}
}<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/connectedComponents.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | linkNodes(dest, src, stats->components);
}
}
}
}
#else
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(stats->components[src] != sampleComp)
{
if(neighbor[src] >= stats->neighbor_rounds)
{
linkNodes(src, dest, stats->components);
}
else
{
neighbor[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/connectedComponents.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ts->algo_numThreads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(stats->components[src] != sampleComp)
{
if(neighbor[src] >= stats->neighbor_rounds)
{
linkNodes(src, dest, stats->components);
}
else
{
neighbor[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/connectedComponents.c | #pragma omp parallel for private(i) schedule (dynamic,arguments->algo_numThreads) | 100 | Start(timer_inner);
change = 0;
stats->iterations++;
uint32_t i;
<LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads)
for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(atomicMin(&(stats->components[dest]), stats->components[src]))
{
setBitAtomic(bitmapNext, dest);
}
if(atomicMin(&(stats->components[src]), stats->components[dest]))
{
setBitAtomic(bitmapNext, 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/connectedComponents.c | #pragma omp parallel for private(j) schedule (dynamic,arguments->algo_numThreads) | 100 | ads)
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
// <LOOP-START>for (j = 0; j < totalPartitions; ++j) // iterate over partitions colwise
{
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];
if(atomicMin(&(stats->components[dest]), stats->components[src]))
{
setBitAtomic(bitmapNext, dest);
}
if(atomicMin(&(stats->components[src]), stats->components[dest]))
{
setBitAtomic(bitmapNext, 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/connectedComponents.c | #pragma omp parallel for reduction (+:change) | 100 | }
}
// compressNodes( stats->num_vertices, stats->components);
<LOOP-START>for(v = 0 ; v < ((bitmapNext->size + kBitsPerWord - 1) / kBitsPerWord); v++)
{
change += bitmapNext->bitarray[v];
bitmapNext->bitarray[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction (+:change)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 512) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
dest = Nodes->edges_array_dest[j];
uint32_t comp_src = stats->components[src];
uint32_t comp_dest = stats->components[dest];
if(comp_src == comp_dest)
continue;
uint32_t comp_high = comp_src > comp_dest ? comp_src : comp_dest;
uint32_t comp_low = comp_src + (comp_dest - comp_high);
if(comp_high == stats->components[comp_high])
{
change = 1;
stats->components[comp_high] = comp_low;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | t(timer);
for(r = 0; r < stats->neighbor_rounds; r++)
{
Start(timer_inner);
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
struct EdgeList *Nodes = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = (0 + r) ; j < (degree_out) ; j++)
{
v = Nodes->edges_array_dest[j];
linkNodes(u, v, stats->components);
break;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | -----------------------------------------------------\n");
Start(timer_inner);
#if DIRECTED
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
if(stats->components[u] == sampleComp)
continue;
struct EdgeList *Nodes_out = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = ( 0 + stats->neighbor_rounds) ; j < (degree_out) ; j++)
{
v = Nodes_out->edges_array_dest[j];
linkNodes(u, v, stats->components);
}
struct EdgeList *Nodes_in = graph->vertices[u].inNodes;
uint32_t degree_in = graph->vertices[u].in_degree;
for(j = (0) ; j < (degree_in) ; j++)
{
v = Nodes_in->edges_array_dest[j];
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | in->edges_array_dest[j];
linkNodes(u, v, stats->components);
}
}
#else
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
if(stats->components[u] == sampleComp)
continue;
struct EdgeList *Nodes_out = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = ( 0 + stats->neighbor_rounds) ; j < (degree_out) ; j++)
{
v = Nodes_out->edges_array_dest[j];
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v) schedule(dynamic, 512) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
struct EdgeList *Nodes_out = graph->vertices[v].outNodes;
uint32_t degree_out = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree_out) ; j++)
{
dest = Nodes_out->edges_array_dest[j];
if(atomicMin(&(stats->components[dest]), stats->components[src]))
{
setBitAtomic(bitmapNext, dest);
}
if(atomicMin(&(stats->components[src]), stats->components[dest]))
{
setBitAtomic(bitmapNext, src);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for reduction (+:change) | 100 | }
}
// compressNodes( stats->num_vertices, stats->components);
<LOOP-START>for(v = 0 ; v < ((bitmapNext->size + kBitsPerWord - 1) / kBitsPerWord); v++)
{
change += bitmapNext->bitarray[v];
bitmapNext->bitarray[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction (+:change)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 512) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
Nodes = graph->vertices[src].outNodes;
degree = graph->vertices[src].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
dest = Nodes->dest;
Nodes = Nodes->next;
uint32_t comp_src = stats->components[src];
uint32_t comp_dest = stats->components[dest];
if(comp_src == comp_dest)
continue;
uint32_t comp_high = comp_src > comp_dest ? comp_src : comp_dest;
uint32_t comp_low = comp_src + (comp_dest - comp_high);
if(comp_high == stats->components[comp_high])
{
change = 1;
stats->components[comp_high] = comp_low;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v,degree,Nodes) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | t(timer);
for(r = 0; r < stats->neighbor_rounds; r++)
{
Start(timer_inner);
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
struct AdjLinkedListNode *Nodes = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = (0 + r) ; j < (degree_out) ; j++)
{
v = Nodes->dest;
Nodes = Nodes->next;
linkNodes(u, v, stats->components);
break;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | -----------------------------------------------------\n");
Start(timer_inner);
#if DIRECTED
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
if(stats->components[u] == sampleComp)
continue;
struct AdjLinkedListNode *Nodes_out = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = ( 0 + stats->neighbor_rounds) ; j < (degree_out) ; j++)
{
v = Nodes_out->dest;
Nodes_out = Nodes_out->next;
linkNodes(u, v, stats->components);
}
struct AdjLinkedListNode *Nodes_in = graph->vertices[u].inNodes;
uint32_t degree_in = graph->vertices[u].in_degree;
for(j = (0) ; j < (degree_in) ; j++)
{
v = Nodes_in->dest;
Nodes_in = Nodes_in->next;
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for schedule(dynamic, 2048) | 100 | es_in = Nodes_in->next;
linkNodes(u, v, stats->components);
}
}
#else
<LOOP-START>for(u = 0; u < graph->num_vertices; u++)
{
uint32_t j;
uint32_t v;
if(stats->components[u] == sampleComp)
continue;
struct AdjLinkedListNode *Nodes_out = graph->vertices[u].outNodes;
uint32_t degree_out = graph->vertices[u].out_degree;
for(j = ( 0 + stats->neighbor_rounds) ; j < (degree_out) ; j++)
{
v = Nodes_out->dest;
Nodes_out = Nodes_out->next;
linkNodes(u, v, stats->components);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 2048)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for private(v) schedule(dynamic, 512) | 100 | change)
{
Start(timer_inner);
change = 0;
stats->iterations++;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
uint32_t j;
uint32_t src = v;
uint32_t dest;
struct AdjLinkedListNode *Nodes_out = graph->vertices[v].outNodes;
uint32_t degree_out = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree_out) ; j++)
{
dest = Nodes_out->dest;
Nodes_out = Nodes_out->next;
if(atomicMin(&(stats->components[dest]), stats->components[src]))
{
setBitAtomic(bitmapNext, dest);
}
if(atomicMin(&(stats->components[src]), stats->components[dest]))
{
setBitAtomic(bitmapNext, src);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) schedule(dynamic, 512)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/connectedComponents.c | #pragma omp parallel for reduction (+:change) | 100 | }
}
// compressNodes( stats->num_vertices, stats->components);
<LOOP-START>for(v = 0 ; v < ((bitmapNext->size + kBitsPerWord - 1) / kBitsPerWord); v++)
{
change += bitmapNext->bitarray[v];
bitmapNext->bitarray[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction (+:change)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/betweennessCentrality.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | ptimization for BFS 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] = UINT32_MAX;
stats->dependency[vertex_id] = 0.0f;
stats->betweennessCentrality[vertex_id] = 0.0f;
stats->sigma[vertex_id] = 0;
stats->realRanks[vertex_id] = vertex_id;
stats->stack->nodes[vertex_id] = 0;
if(graph->vertices->out_degree[vertex_id])
stats->parents[vertex_id] = graph->vertices->out_degree[vertex_id] * (-1);
else
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/betweennessCentrality.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats) | 100 | ptimization for BFS implentaion instead of -1 we use -out degree to for hybrid approach counter
<LOOP-START>for(vertex_id = 0; vertex_id < stats->num_vertices ; vertex_id++)
{
stats->distances[vertex_id] = UINT32_MAX;
stats->dependency[vertex_id] = 0.0f;
stats->sigma[vertex_id] = 0;
stats->stack->nodes[vertex_id] = 0;
stats->predecessors[vertex_id].degree = 0;
stats->parents[vertex_id] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/betweennessCentrality.c | #pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) | 100 | graph->vertices;
sorted_edges_array = graph->sorted_edges_array->edges_array_dest;
#endif
<LOOP-START>for(v = 0 ; v < graph->num_vertices ; v++)
{
out_degree = vertices->out_degree[v];
if(stats->distances[v] == UINT32_MAX) // optmization
{
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + out_degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (bitmapCurr->bitarray[word_offset(u)]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
if(getBit(bitmapCurr, u))
{
// stats->parents[v] = u;
stats->distances[v] = stats->distances[u] + 1;
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->distances[u]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
if(stats->distances[v] == stats->distances[u] + 1)
{
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->sigma[u]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (stats->sigma[u]), 'w', u, EXTRACT_MASK(sorted_edges_array[j]));
stats->sigma[v] += stats->sigma[u];
stats->predecessors[v].nodes[stats->predecessors[v].degree] = u;
stats->predecessors[v].degree++;
}
setBitAtomic(bitmapNext, v);
nf++;
// break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | ptimization for BFS 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_DualOrder[vertex_id] = 0;
if(graph->vertices->out_degree[vertex_id])
{
stats->parents[vertex_id] = graph->vertices->out_degree[vertex_id] * (-1);
stats->parents_DualOrder[vertex_id] = graph->vertices->out_degree[vertex_id] * (-1);
}
else
{
stats->parents[vertex_id] = -1;
stats->parents_DualOrder[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/BFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | s->iteration = 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/BFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | ptimization for BFS 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;
if(graph->vertices[vertex_id].out_degree)
stats->parents[vertex_id] = graph->vertices[vertex_id].out_degree * (-1);
else
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/BFS.c | #pragma omp parallel for default(none) private(vertex_id) shared(stats,graph) | 100 | ptimization for BFS 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;
if(graph->vertices[vertex_id].out_degree)
stats->parents[vertex_id] = graph->vertices[vertex_id].out_degree * (-1);
else
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/BFS.c | #pragma omp parallel for default(none) private(vertex_id,vertex_v) shared(parents,parents_DualOrder,labels,num_vertices) num_threads(num_threads_max) | 100 | int32_t vertex_v;
int *parents_temp;
uint32_t num_threads_max = omp_get_max_threads();
<LOOP-START>for(vertex_id = 0; vertex_id < num_vertices ; vertex_id++)
{
vertex_v = labels[vertex_id];
// vertex_u = inv_labels[vertex_id];
if((*parents)[vertex_id] >= 0)
{
(*parents_DualOrder)[vertex_v] = labels[(*parents)[vertex_id]];
}
else
{
(*parents_DualOrder)[vertex_v] = (*parents)[vertex_id];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id,vertex_v) shared(parents,parents_DualOrder,labels,num_vertices) num_threads(num_threads_max)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(vertex_id,vertex_v) shared(distances,distances_DualOrder,labels,num_vertices) num_threads(num_threads_max) | 100 | vertex_u;
uint32_t *distances_temp;
uint32_t num_threads_max = omp_get_max_threads();
<LOOP-START>for(vertex_id = 0; vertex_id < num_vertices ; vertex_id++)
{
vertex_v = labels[vertex_id];
// vertex_u = inv_labels[vertex_id];
distances_DualOrder[vertex_v] = distances[vertex_id];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(vertex_id,vertex_v) shared(distances,distances_DualOrder,labels,num_vertices) num_threads(num_threads_max)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) num_threads(1) | 100 | sorted_edges_array = graph->sorted_edges_array->edges_array_dest;
#endif
#ifdef CACHE_HARNESS
<LOOP-START>#else
#pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024)
for(v = 0 ; v < graph->num_vertices ; v++)
{
out_degree = vertices->out_degree[v];
if(stats->parents[v] < 0) // optmization
{
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + out_degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (bitmapCurr->bitarray[word_offset(u)]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
if(getBit(bitmapCurr, u))
{
stats->parents[v] = u;
//we are not considering distance array as it is not implemented in AccelGraph
stats->distances[v] = stats->distances[u] + 1;
setBitAtomic(bitmapNext, v);
// #ifdef CACHE_HARNESS
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (stats->parents[v]), 'w', v, stats->parents[v]);
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (bitmapNext->bitarray[word_offset(v)]), 'w', v, (bitmapNext->bitarray[word_offset(v)]));
//
nf++;
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) num_threads(1)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) | 100 | graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) num_threads(1)
#else
<LOOP-START>for(v = 0 ; v < graph->num_vertices ; v++)
{
out_degree = vertices->out_degree[v];
if(stats->parents[v] < 0) // optmization
{
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + out_degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (bitmapCurr->bitarray[word_offset(u)]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
if(getBit(bitmapCurr, u))
{
stats->parents[v] = u;
//we are not considering distance array as it is not implemented in AccelGraph
stats->distances[v] = stats->distances[u] + 1;
setBitAtomic(bitmapNext, v);
// #ifdef CACHE_HARNESS
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (stats->parents[v]), 'w', v, stats->parents[v]);
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (bitmapNext->bitarray[word_offset(v)]), 'w', v, (bitmapNext->bitarray[word_offset(v)]));
//
nf++;
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024) | 100 | graph->vertices;
sorted_edges_array = graph->sorted_edges_array->edges_array_dest;
#endif
<LOOP-START>for(v = 0 ; v < graph->num_vertices ; v++)
{
out_degree = vertices->out_degree[v];
if(stats->parents[v] < 0) // optmization
{
edge_idx = vertices->edges_idx[v];
for(j = edge_idx ; j < (edge_idx + out_degree) ; j++)
{
u = EXTRACT_VALUE(sorted_edges_array[j]);
#ifdef CACHE_HARNESS
AccessDoubleTaggedCacheUInt32(stats->cache, (uint64_t) & (bitmapCurr->bitarray[word_offset(u)]), 'r', u, EXTRACT_MASK(sorted_edges_array[j]));
if(getBit(bitmapCurr, u))
{
stats->parents[v] = u;
//we are not considering distance array as it is not implemented in AccelGraph
stats->distances[v] = stats->distances[u] + 1;
setBitAtomic(bitmapNext, v);
// #ifdef CACHE_HARNESS
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (stats->parents[v]), 'w', v, stats->parents[v]);
// AccessDoubleTaggedCacheFloat(stats->cache, (uint64_t) & (bitmapNext->bitarray[word_offset(v)]), 'w', v, (bitmapNext->bitarray[word_offset(v)]));
//
nf++;
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(j,u,v,out_degree,edge_idx) shared(stats,bitmapCurr,bitmapNext,graph,vertices,sorted_edges_array) reduction(+:nf) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for | 100 | rQueues = (struct ArrayQueue **) my_malloc( P * sizeof(struct ArrayQueue *));
uint32_t i;
<LOOP-START>for(i = 0 ; i < P ; i++)
{
localFrontierQueues[i] = newArrayQueue(graph->num_vertices);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for | 100 |
for(i = 0 ; i < P ; i++)
{
freeArrayQueue(localFrontierQueues[i]);
}
// <LOOP-START>// for(i=0 ; i < P*P ; i++){
// freeArrayQueue(localFrontierQueuesL2[i]);
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for | 100 | rQueues = (struct ArrayQueue **) my_malloc( P * sizeof(struct ArrayQueue *));
uint32_t i;
<LOOP-START>for(i = 0 ; i < P ; i++)
{
localFrontierQueues[i] = newArrayQueue(graph->num_vertices);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for | 100 |
for(i = 0 ; i < P ; i++)
{
freeArrayQueue(localFrontierQueues[i]);
}
// <LOOP-START>// for(i=0 ; i < P*P ; i++){
// freeArrayQueue(localFrontierQueuesL2[i]);
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) shared(i,stats,totalPartitions,localFrontierQueues ,sharedFrontierQueue, graph) | 100 | xP
uint32_t i;
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t t_id = omp_get_thread_num();
// uint32_t A = 0;
struct ArrayQueue *localFrontierQueue = localFrontierQueues[t_id];
if(getBit(graph->grid->activePartitionsMap, (i * totalPartitions) + j))
{
// #pragma omp task untied
// {
breadthFirstSearchPartitionGraphGrid(graph, &(graph->grid->partitions[(i * totalPartitions) + j]), sharedFrontierQueue, localFrontierQueue, stats);
flushArrayQueueToShared(localFrontierQueue, sharedFrontierQueue);
// }
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(i,stats,totalPartitions,localFrontierQueues ,sharedFrontierQueue, graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) shared(graph,sharedFrontierQueue) private(i,v) schedule(dynamic,1024) | 100 | aphGridResetActivePartitions(graph->grid);
graphGridResetActivePartitionsMap(graph->grid);
<LOOP-START>for(i = sharedFrontierQueue->head ; i < sharedFrontierQueue->tail; i++)
{
v = sharedFrontierQueue->queue[i];
// graphGridSetActivePartitions(graph->grid, v);
// if(getBit(graph->grid->activePartitionsMap,i))
graphGridSetActivePartitionsMap(graph->grid, v);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(graph,sharedFrontierQueue) private(i,v) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) shared(i,stats,totalPartitions,FrontierBitmapCurr ,FrontierBitmapNext, graph) | 100 | // PxP
uint32_t i;
for (i = 0; i < totalPartitions; ++i)
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
if(getBit(graph->grid->activePartitionsMap, (i * totalPartitions) + j) && graph->grid->partitions[(i * totalPartitions) + j].num_edges)
{
breadthFirstSearchPartitionGraphGridBitmap(graph, &(graph->grid->partitions[(i * totalPartitions) + j]), FrontierBitmapCurr, FrontierBitmapNext, stats);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(i,stats,totalPartitions,FrontierBitmapCurr ,FrontierBitmapNext, graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) shared(graph,FrontierBitmap) private(i) schedule(dynamic,1024) | 100 | itmap *FrontierBitmap)
{
uint32_t i;
graphGridResetActivePartitionsMap(graph->grid);
<LOOP-START>for(i = 0 ; i < FrontierBitmap->size; i++)
{
if(getBit(FrontierBitmap, i))
graphGridSetActivePartitionsMap(graph->grid, i);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(graph,FrontierBitmap) private(i) schedule(dynamic,1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(Nodes,j,u,v,degree) shared(stats,bitmapCurr,bitmapNext,graph) reduction(+:nf) schedule(dynamic, 1024) | 100 | stats->processed_nodes += processed_nodes;
uint32_t degree;
struct EdgeList *Nodes;
<LOOP-START>for(v = 0 ; v < graph->num_vertices ; v++)
{
if(stats->parents[v] < 0) // optmization
{
#if DIRECTED // will look at the other neighbours if directed by using inverese edge list
Nodes = graph->vertices[v].inNodes;
degree = graph->vertices[v].in_degree;
#else
Nodes = graph->vertices[v].outNodes;
degree = graph->vertices[v].out_degree;
for(j = 0 ; j < (degree) ; j++)
{
u = Nodes->edges_array_dest[j];
if(getBit(bitmapCurr, u))
{
stats->parents[v] = u;
setBitAtomic(bitmapNext, v);
stats->distances[v] = stats->distances[u] + 1;
nf++;
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,j,u,v,degree) shared(stats,bitmapCurr,bitmapNext,graph) reduction(+:nf) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/BFS.c | #pragma omp parallel for default(none) private(Nodes,j,u,v,degree) shared(stats,bitmapCurr,bitmapNext,graph) reduction(+:nf) schedule(dynamic, 1024) | 100 | ocessed_nodes += processed_nodes;
uint32_t degree;
struct AdjLinkedListNode *Nodes;
<LOOP-START>for(v = 0 ; v < graph->num_vertices ; v++)
{
if(stats->parents[v] < 0) // optmization
{
#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;
Nodes = Nodes->next;
if(getBit(bitmapCurr, u))
{
stats->parents[v] = u;
setBitAtomic(bitmapNext, v);
stats->distances[v] = stats->distances[u] + 1;
nf++;
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(Nodes,j,u,v,degree) shared(stats,bitmapCurr,bitmapNext,graph) reduction(+:nf) schedule(dynamic, 1024)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SSSP.c | #pragma omp parallel for | 100 | (uint32_t));
stats->buckets_map = (uint32_t *) my_malloc(num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < num_vertices; v++)
{
stats->buckets_map[v] = UINT_MAX / 2;
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/SSSP.c | #pragma omp parallel for | 100 | _t));
stats->buckets_map = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->buckets_map[v] = UINT_MAX / 2;
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/SSSP.c | #pragma omp parallel for | 100 | _t));
stats->buckets_map = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->buckets_map[v] = UINT_MAX / 2;
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/SSSP.c | #pragma omp parallel for | 100 | _t));
stats->buckets_map = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->buckets_map[v] = UINT_MAX / 2;
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/SSSP.c | #pragma omp parallel for | 100 | _t));
stats->buckets_map = (uint32_t *) my_malloc(graph->num_vertices * sizeof(uint32_t));
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->buckets_map[v] = UINT_MAX / 2;
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/SSSP.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/SSSP.c | #pragma omp parallel for private(e,weight) shared(graph,delta) reduction(+:edgesPlusCounter,edgesMinusCounter) | 100 | MinusCounter = 0;
uint32_t e;
float weight;
// uint32_t src;
// uint32_t dest;
<LOOP-START>for(e = 0 ; e < graph->num_edges ; e++)
{
// src = graph->sorted_edges_array[e].src;
// dest = graph->sorted_edges_array[e].dest;
weight = 1;
#if WEIGHTED
weight = graph->sorted_edges_array->edges_array_weight[e];
if(weight > delta)
{
edgesPlusCounter++;
}
else if (weight <= delta)
{
edgesMinusCounter++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(e,weight) shared(graph,delta) reduction(+:edgesPlusCounter,edgesMinusCounter)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SSSP.c | #pragma omp parallel for private(e,weight) shared(edgesMinus_idx,edgesPlus_idx,edgesPlus,edgesMinus,graph) | 100 | t(edgesMinusCounter);
#endif
uint32_t edgesPlus_idx = 0;
uint32_t edgesMinus_idx = 0;
<LOOP-START>for(e = 0 ; e < graph->num_edges ; e++)
{
weight = 1;
#if WEIGHTED
weight = graph->sorted_edges_array->edges_array_weight[e];
uint32_t index = 0;
if(weight > delta)
{
index = __sync_fetch_and_add(&edgesPlus_idx, 1);
edgesPlus->edges_array_dest[index] = graph->sorted_edges_array->edges_array_dest[e];
edgesPlus->edges_array_src[index] = graph->sorted_edges_array->edges_array_src[e];
#if WEIGHTED
edgesPlus->edges_array_weight[index] = graph->sorted_edges_array->edges_array_weight[e];
#if DIRECTED
edgesPlusInverse->edges_array_dest[index] = graph->sorted_edges_array->edges_array_src[e];
edgesPlusInverse->edges_array_src[index] = graph->sorted_edges_array->edges_array_dest[e];
#if WEIGHTED
edgesPlusInverse->edges_array_weight[index] = graph->sorted_edges_array->edges_array_weight[e];
}
else if (weight <= delta)
{
index = __sync_fetch_and_add(&edgesMinus_idx, 1);
edgesMinus->edges_array_dest[index] = graph->sorted_edges_array->edges_array_dest[e];
edgesMinus->edges_array_src[index] = graph->sorted_edges_array->edges_array_src[e];
#if WEIGHTED
edgesMinus->edges_array_weight[index] = graph->sorted_edges_array->edges_array_weight[e];
#if DIRECTED
edgesMinusInverse->edges_array_dest[index] = graph->sorted_edges_array->edges_array_src[e];
edgesMinusInverse->edges_array_src[index] = graph->sorted_edges_array->edges_array_dest[e];
#if WEIGHTED
edgesMinusInverse->edges_array_weight[index] = graph->sorted_edges_array->edges_array_weight[e];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(e,weight) shared(edgesMinus_idx,edgesPlus_idx,edgesPlus,edgesMinus,graph)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SSSP.c | #pragma omp parallel for private(v) shared(bitmapSetCurr, graph, stats) reduction(+ : activeVertices) | 100 | = 0;
// uint32_t buckets_total_local =
// process light edges
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(__sync_bool_compare_and_swap(&(stats->buckets_map[v]), stats->bucket_current, (UINT_MAX / 2)))
{
// if(stats->buckets_map[v] == stats->bucket_current) {
// pop vertex from bucket list
setBitAtomic(bitmapSetCurr, v);
#pragma omp atomic update
stats->buckets_total--;
// stats->buckets_map[v] = UINT_MAX/2;
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 += SSSPRelax(src, dest, weight, stats);
else
activeVertices += SSSPAtomicRelax(src, dest, weight, stats);
}
}
}
Stop(timer_inner);
if(activeVertices)
printf("| L%-14u | %-15u | %-15f |\n", iter, stats->buckets_total, Seconds(timer_inner));
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(bitmapSetCurr, graph, stats) reduction(+ : activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SSSP.c | #pragma omp parallel for private(v) shared(bitmapSetCurr, graphLight, stats) reduction(+ : activeVertices) | 100 | r = 0;
// uint32_t buckets_total_local =
// process light edges
<LOOP-START>for(v = 0; v < graphLight->num_vertices; v++)
{
if(__sync_bool_compare_and_swap(&(stats->buckets_map[v]), stats->bucket_current, (UINT_MAX / 2)))
{
// if(stats->buckets_map[v] == stats->bucket_current) {
// pop vertex from bucket list
setBitAtomic(bitmapSetCurr, v);
#pragma omp atomic update
stats->buckets_total--;
// stats->buckets_map[v] = UINT_MAX/2;
uint32_t degree = graphLight->vertices->out_degree[v];
uint32_t edge_idx = graphLight->vertices->edges_idx[v];
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t src = EXTRACT_VALUE(graphLight->sorted_edges_array->edges_array_src[j]);
uint32_t dest = EXTRACT_VALUE(graphLight->sorted_edges_array->edges_array_dest[j]);
float weight = 1;
#if WEIGHTED
weight = graphLight->sorted_edges_array->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += SSSPRelax(src, dest, weight, stats);
else
activeVertices += SSSPAtomicRelax(src, dest, weight, stats);
}
}
}
Stop(timer_inner);
if(activeVertices)
printf("| L%-14u | %-15u | %-15f |\n", iter, stats->buckets_total, Seconds(timer_inner));
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(bitmapSetCurr, graphLight, stats) reduction(+ : activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/SSSP.c | #pragma omp parallel for private(v) shared(bitmapSetCurr, graphHeavy, stats) reduction(+ : activeVertices) | 100 | Marker(2, iteration);
SimMarker(3, iteration);
#endif
Start(timer_inner);
<LOOP-START>for(v = 0; v < graphHeavy->num_vertices; v++)
{
if(getBit(bitmapSetCurr, v))
{
uint32_t degree = graphHeavy->vertices->out_degree[v];
uint32_t edge_idx = graphHeavy->vertices->edges_idx[v];
uint32_t j;
for(j = edge_idx ; j < (edge_idx + degree) ; j++)
{
uint32_t src = EXTRACT_VALUE(graphHeavy->sorted_edges_array->edges_array_src[j]);
uint32_t dest = EXTRACT_VALUE(graphHeavy->sorted_edges_array->edges_array_dest[j]);
float weight = 1;
#if WEIGHTED
weight = graphHeavy->sorted_edges_array->edges_array_weight[j];
if(arguments->algo_numThreads == 1)
activeVertices += SSSPRelax(src, dest, weight, stats);
else
activeVertices += SSSPAtomicRelax(src, dest, weight, stats);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(bitmapSetCurr, graphHeavy, stats) reduction(+ : activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));;
stats->pageRanks = (float *) my_malloc(graph->num_vertices * sizeof(float));;
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->pageRanks[v] = stats->base_pr;
stats->realRanks[v] = v;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));;
stats->pageRanks = (float *) my_malloc(graph->num_vertices * sizeof(float));;
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->pageRanks[v] = stats->base_pr;
stats->realRanks[v] = v;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));;
stats->pageRanks = (float *) my_malloc(graph->num_vertices * sizeof(float));;
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->pageRanks[v] = stats->base_pr;
stats->realRanks[v] = v;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(stats) | 100 | int32_t));;
stats->pageRanks = (float *) my_malloc(graph->num_vertices * sizeof(float));;
<LOOP-START>for(v = 0; v < stats->num_vertices; v++)
{
stats->pageRanks[v] = stats->base_pr;
stats->realRanks[v] = v;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(stats)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | ");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->grid->out_degree[v];
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(i) | 100 | amEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
#pragma omp parallel for private(j)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
// __sync_fetch_and_add(&pageRanksNext[dest],riDividedOnDiClause[src]);
// addAtomicFloat(float *num, float value)
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(j) | 100 | lPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
// __sync_fetch_and_add(&pageRanksNext[dest],riDividedOnDiClause[src]);
// addAtomicFloat(float *num, float value)
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext, stats) reduction(+ : error_total, activeVertices) | 100 | geRanksNext[dest] += riDividedOnDiClause[src];
}
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * pageRanksNext[v]);
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext, stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | );
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->grid->out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(i) | 100 | amEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
#pragma omp parallel for private(j)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(j) | 100 | lPartitions; ++i) // iterate over partitions rowwise
{
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | geRanksNext[dest] += riDividedOnDiClause[src];
}
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * Fixed64ToDouble(pageRanksNext[v]));
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | ");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
riDividedOnDiClause[v] = stats->pageRanks[v] / graph->grid->out_degree[v];
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(j) | 100 | treamEdgesGraphGridRowWise(graph, riDividedOnDiClause, pageRanksNext);
uint32_t j;
<LOOP-START>for (j = 0; j < totalPartitions; ++j)
{
uint32_t i;
// #pragma omp parallel for private(i) // iterate over partitions columnwise
for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
// addAtomicFloat(&pageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(i) | 100 | (j)
for (j = 0; j < totalPartitions; ++j)
{
uint32_t i;
// <LOOP-START>for (i = 0; i < totalPartitions; ++i)
{
uint32_t k;
uint32_t src;
uint32_t dest;
struct Partition *partition = &graph->grid->partitions[(i * totalPartitions) + j];
for (k = 0; k < partition->num_edges; ++k)
{
src = partition->edgeList->edges_array_src[k];
dest = partition->edgeList->edges_array_dest[k];
// #pragma omp atomic update
pageRanksNext[dest] += riDividedOnDiClause[src];
// addAtomicFloat(&pageRanksNext[dest] , riDividedOnDiClause[src]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i) <OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices) | 100 | ageRanksNext[dest] , riDividedOnDiClause[src]);
}
}
}
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
float prevPageRank = stats->pageRanks[v];
float nextPageRank = stats->base_pr + (stats->damp * pageRanksNext[v]);
stats->pageRanks[v] = nextPageRank;
pageRanksNext[v] = 0.0f;
double error = fabs( nextPageRank - prevPageRank);
error_total += (error / graph->num_vertices);
if(error >= arguments->epsilon)
{
activeVertices++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(v) shared(arguments, pageRanksNext,stats) reduction(+ : error_total, activeVertices)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for reduction(+:sum) | 100 | if(activeVertices == 0)
break;
}// end iteration loop
double sum = 0.0f;
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
stats->pageRanks[v] = stats->pageRanks[v] / graph->num_vertices;
sum += stats->pageRanks[v];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext) | 100 | ");
printf(" -----------------------------------------------------\n");
Start(timer);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
pageRanksNext[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) private(v) shared(graph,pageRanksNext)<OMP-END> |
atmughrabi/OpenGraphSim/00_graph_bench/src/algorithms/openmp/pageRank.c | #pragma omp parallel for | 100 | s++)
{
error_total = 0;
activeVertices = 0;
Start(timer_inner);
<LOOP-START>for(v = 0; v < graph->num_vertices; v++)
{
if(graph->grid->out_degree[v])
riDividedOnDiClause[v] = DoubleToFixed64(stats->pageRanks[v] / graph->grid->out_degree[v]);
else
riDividedOnDiClause[v] = 0.0f;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.