int
main (int argc, char ** argv)
{
stinger_t * S = stinger_new();
/* insert your data now */
load_benchmark_data_into_stinger (S, argv[1],0);
/* get number of vertices */
uint64_t nv = stinger_max_active_vertex (S);
nv++;
print_fragmentation_stats (S, nv);
/* auxiliary data structure */
double * pagerank_scores = xmalloc (nv * sizeof(int64_t));
double * pagerank_scores_tmp = xmalloc (nv * sizeof(int64_t));
/* the algorithm itself (timed) */
bench_start();
pagerank (S, nv, pagerank_scores, pagerank_scores_tmp, 1e-8, 0.85, 100);
bench_end();
printf("Done.\n");
/* cleanup */
free (pagerank_scores);
free (pagerank_scores_tmp);
stinger_free_all (S);
return 0;
}
int main(int argc, char** argv) {
struct timeval first, second, lapsed;
struct timezone tzp;
printf("Sequential PageRank algorithm\n");
nodes = (node_struct*)malloc(N*sizeof(node_struct));
/***Run the next 2 functions for a full web graph PageRank calculation**/
//rand_init();
init();
read_data();
/*Pagerank algorithm*/
gettimeofday(&first, &tzp);
pagerank();
gettimeofday(&second, &tzp);
if(first.tv_usec>second.tv_usec){
second.tv_usec += 1000000;
second.tv_sec--;
}
lapsed.tv_usec = second.tv_usec - first.tv_usec;
lapsed.tv_sec = second.tv_sec - first.tv_sec;
printf("\nTotal time elapsed: %d, %d s\n", lapsed.tv_sec, lapsed.tv_usec);
//save_results();
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
long size, vr;
long *vals = malloc(80000000*sizeof(long));
long *col_inds = malloc(80000000*sizeof(long));
long *row_ptrs = malloc(80000000*sizeof(long));
double *vec = malloc(80000000*sizeof(double));
// printf("Enter size: \n");
// scanf("%d",&size);
// printf("Enter row ptr size: \n");
// scanf("%d",&vr);
read_graphs(argv,&size,&vr,vals,col_inds,row_ptrs,vec);
long i;
// printf("\n Vals: \n");
// for(i=0; i<size; i++) {
// printf("%ld ",vals[i]);
// }
//
// printf("\n Cols: \n");
// for(i=0; i<size; i++) {
// printf("%ld ",col_inds[i]);
// }
//
// printf("\n Rows: \n");
// for(i=0; i<vr; i++) {
// printf("%ld ",row_ptrs[i]);
// }
//
// printf("\n Vector: \n");
// for(i=0; i<vr-1; i++) {
// printf("%f ",vec[i]);
// }
pagerank(size,vr,vals,col_inds,row_ptrs,vec);
}
int main(void) {
/*
######################################################
### DO NOT MODIFY THE MAIN FUNCTION OR HEADER FILE ###
######################################################
*/
list* plist = NULL;
double dampener;
int ncores, npages, nedges;
/* read the input then populate settings and the list of pages */
read_input(&plist, &ncores, &npages, &nedges, &dampener);
/* run pagerank and output the results */
pagerank(plist, ncores, npages, nedges, dampener);
/* clean up the memory used by the list of pages */
page_list_destroy(plist);
return 0;
}
int main(int argc, char ** argv) {
if (argc<3) {
fprintf(stderr, "usage: pagerank [path] [iterations] [memory budget in GB]\n");
exit(-1);
}
std::string path = argv[1];
int iterations = atoi(argv[2]);
long memory_bytes = (argc>=4)?atol(argv[3])*1024l*1024l*1024l:8l*1024l*1024l*1024l;
Graph graph(path,atoi(argv[4]));
graph.set_memory_bytes(memory_bytes);
BigVector<VertexId> degree(graph.path+"/degree", graph.vertices);
BigVector<float> pagerank(graph.path+"/pagerank", graph.vertices);
BigVector<float> sum(graph.path+"/sum", graph.vertices);
long vertex_data_bytes = (long)graph.vertices * ( sizeof(VertexId) + sizeof(float) + sizeof(float) );
graph.set_vertex_data_bytes(vertex_data_bytes);
double begin_time = get_time();
degree.fill(0);
graph.stream_edges<VertexId>(
[&](Edge & e){
write_add(°ree[e.source], 1);
return 0;
}, nullptr, 0, 0
);
printf("degree calculation used %.2f seconds\n", get_time() - begin_time);
fflush(stdout);
graph.hint(pagerank, sum);
graph.stream_vertices<VertexId>(
[&](VertexId i){
pagerank[i] = 1.f / degree[i];
sum[i] = 0;
return 0;
}, nullptr, 0,
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.load(vid_range.first, vid_range.second);
sum.load(vid_range.first, vid_range.second);
},
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.save();
sum.save();
}
);
for (int iter=0;iter<iterations;iter++) {
graph.hint(pagerank);
graph.stream_edges<VertexId>(
[&](Edge & e){
write_add(&sum[e.target], pagerank[e.source]);
return 0;
}, nullptr, 0, 1,
[&](std::pair<VertexId,VertexId> source_vid_range){
pagerank.lock(source_vid_range.first, source_vid_range.second);
},
[&](std::pair<VertexId,VertexId> source_vid_range){
pagerank.unlock(source_vid_range.first, source_vid_range.second);
}
);
graph.hint(pagerank, sum);
if (iter==iterations-1) {
graph.stream_vertices<VertexId>(
[&](VertexId i){
pagerank[i] = 0.15f + 0.85f * sum[i];
return 0;
}, nullptr, 0,
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.load(vid_range.first, vid_range.second);
},
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.save();
}
);
} else {
graph.stream_vertices<float>(
[&](VertexId i){
pagerank[i] = (0.15f + 0.85f * sum[i]) / degree[i];
sum[i] = 0;
return 0;
}, nullptr, 0,
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.load(vid_range.first, vid_range.second);
sum.load(vid_range.first, vid_range.second);
},
[&](std::pair<VertexId,VertexId> vid_range){
pagerank.save();
sum.save();
}
);
}
}
double end_time = get_time();
printf("%d iterations of pagerank took %.2f seconds\n", iterations, end_time - begin_time);
}
