/**

void update(graphchi_vertex<VertexDataType, EdgeDataType> &vertex, graphchi_context &gcontext) {

/* This program requires selective scheduling. */

assert(gcontext.scheduler != NULL);

vid_t newlabel;

if (gcontext.iteration == 0) {

/* On first iteration, choose label vertex id */

vid_t firstlabel = vertex.id();

vertex.set_data(firstlabel);

newlabel = firstlabel;

/* Scheduler myself for next iteration */

gcontext.scheduler->add_task(vertex.id());

} else {

if (vertex.num_edges() == 0) return; // trivial

/* The basic idea is to find the label that is most popular among

// This part could be optimized: STL map is quite slow.

std::map<vid_t, int> counts;

int maxcount=0;

vid_t maxlabel=0;

/* Iterate over all the edges */

for(int i=0; i < vertex.num_edges(); i++) {

/* Extract neighbor's current label. The edge contains the labels of

bidirectional_label edgelabel = vertex.edge(i)->get_data();

vid_t nblabel = neighbor_label(edgelabel, vertex.id(), vertex.edge(i)->vertex_id());

/* Check if this label (nblabel) has been encountered before ... */

std::map<vid_t, int>::iterator existing = counts.find(nblabel);

int newcount = 0;

if(existing == counts.end()) {

/* ... if not, we add this label with count of one to the map */

counts.insert(std::pair<vid_t,int>(nblabel, 1));

newcount = 1;

} else {

/* ... if yes, we increment the counter for this label by 1 */

existing->second++;

newcount = existing->second;

}

/* Finally, we keep track of the most frequent label */

if (newcount > maxcount || (maxcount == newcount && nblabel > maxlabel)) {

maxlabel = nblabel;

maxcount = newcount;

}

}

newlabel = maxlabel;

}

/**

if (newlabel != vertex.get_data() || gcontext.iteration == 0) {

vertex.set_data(newlabel);

for(int i=0; i<vertex.num_edges(); i++) {

bidirectional_label labels_on_edge = vertex.edge(i)->get_data();

my_label(labels_on_edge, vertex.id(), vertex.edge(i)->vertex_id()) = newlabel;

vertex.edge(i)->set_data(labels_on_edge);

// On first iteration, everyone schedules themselves.

if (gcontext.iteration > 0)

gcontext.scheduler->add_task(vertex.edge(i)->vertex_id());

}

}

}

/**

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 after_exec_interval(vid_t window_st, vid_t window_en, graphchi_context &ginfo) {

}

/* GraphChi initialization will read the command line

graphchi_init(argc, argv);

/* Metrics object for keeping track of performance counters

metrics m("community-detection");

/* Basic arguments for application */

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

int niters = get_option_int("niters", 10); // Number of iterations (max)

bool scheduler = true; // Always run with scheduler

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

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

if (get_option_int("onlyresult", 0) == 0) {

/* Run */

CommunityDetectionProgram program;

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

engine.run(program, niters);

}

/* Run analysis of the communities (output is written to a file) */

m.start_time("label-analysis");

analyze_labels<vid_t>(filename);

m.stop_time("label-analysis");

/* Report execution metrics */

metrics_report(m);

return 0;