/**

void before_iteration(int iteration, graphchi_context &info) {

}

/**

void after_iteration(int iteration, graphchi_context &ginfo) {

}

/**

void before_exec_interval(vid_t window_st, vid_t window_en, graphchi_context &ginfo) {

}

/**

void update(graphchi_vertex<VertexDataType, EdgeDataType> &v, graphchi_context &ginfo) {

float sum=0;

if (ginfo.iteration == 0) {

/* On first iteration, initialize vertex and out-edges.

for(int i=0; i < v.num_outedges(); i++) {

graphchi_edge<float> * edge = v.outedge(i);

edge->set_data(1.0 / v.num_outedges());

}

v.set_data(RANDOMRESETPROB);

} else {

/* Compute the sum of neighbors' weighted pageranks by

for(int i=0; i < v.num_inedges(); i++) {

float val = v.inedge(i)->get_data();

sum += val;

}

/* Compute my pagerank */

float pagerank = RANDOMRESETPROB + (1 - RANDOMRESETPROB) * sum;

/* Write my pagerank divided by the number of out-edges to

if (v.num_outedges() > 0) {

float pagerankcont = pagerank / v.num_outedges();

for(int i=0; i < v.num_outedges(); i++) {

graphchi_edge<float> * edge = v.outedge(i);

edge->set_data(pagerankcont);

}

}

/* Keep track of the progression of the computation.

ginfo.log_change(std::abs(pagerank - v.get_data()));

/* Set my new pagerank as the vertex value */

v.set_data(pagerank);

}

}

std::vector<EdgeDataType> pr;

PagerankProgramInmem(int nvertices) : pr(nvertices, RANDOMRESETPROB) {}

void update(graphchi_vertex<VertexDataType, EdgeDataType> &v, graphchi_context &ginfo) {

if (ginfo.iteration > 0) {

float sum=0;

for(int i=0; i < v.num_inedges(); i++) {

sum += pr[v.inedge(i)->vertexid];

}

if (v.outc > 0) {

pr[v.id()] = (RANDOMRESETPROB + (1 - RANDOMRESETPROB) * sum) / v.outc;

} else {

pr[v.id()] = (RANDOMRESETPROB + (1 - RANDOMRESETPROB) * sum);

}

} else if (ginfo.iteration == 0) {

if (v.outc > 0) pr[v.id()] = 1.0f / v.outc;

}

if (ginfo.iteration == ginfo.num_iterations - 1) {

/* On last iteration, multiply pr by degree and store the result */

v.set_data(v.outc > 0 ? pr[v.id()] * v.outc : pr[v.id()]);

}

}

graphchi_init(argc, argv);

metrics m("pagerank");

global_logger().set_log_level(LOG_DEBUG);

/* Parameters */

std::string filename = get_option_string("file"); // Base filename

int niters = get_option_int("niters", 4);

bool scheduler = false; // Non-dynamic version of pagerank.

int ntop = get_option_int("top", 20);

/* Process input file - if not already preprocessed */

int nshards = convert_if_notexists<EdgeDataType>(filename, get_option_string("nshards", "auto"));

/* Run */

graphchi_engine<float, float> engine(filename, nshards, scheduler, m);

engine.set_modifies_inedges(false); // Improves I/O performance.

bool inmemmode = engine.num_vertices() * sizeof(EdgeDataType) < (size_t)engine.get_membudget_mb() * 1024L * 1024L;

if (inmemmode) {

logstream(LOG_INFO) << "Running Pagerank by holding vertices in-memory mode!" << std::endl;

engine.set_modifies_outedges(false);

engine.set_disable_outedges(true);

engine.set_only_adjacency(true);

PagerankProgramInmem program(engine.num_vertices());

engine.run(program, niters);

} else {

PagerankProgram program;

engine.run(program, niters);

}

/* Output top ranked vertices */

std::vector< vertex_value<float> > top = get_top_vertices<float>(filename, ntop);

std::cout << "Print top " << ntop << " vertices:" << std::endl;

for(int i=0; i < (int)top.size(); i++) {

std::cout << (i+1) << ". " << top[i].vertex << "\t" << top[i].value << std::endl;

}

metrics_report(m);

return 0;