mutex lock;

/**

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

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

chivector<vid_t> * evector = vertex.edge(i)->get_vector();

assert(evector != NULL);

// Each edge has three or one values in the chi vector

int numelems = ((vertex.id() + vertex.edge(i)->vertex_id()) % 3 == 1 ? 3 : 1);

for(int k=0; k < numelems ; k++) {

vid_t expected = vertex.id() + vertex.edge(i)->vertex_id() + k;

if (expected != evector->get(k)) {

logstream(LOG_ERROR) << "Vertex " << vertex.id() << ", edge dst: " << vertex.edge(i)->vertex_id() << std::endl;

logstream(LOG_ERROR) << "Mismatch (" << k << "): expected " << expected << " but had " << evector->get(k) << std::endl;

}

assert(evector->get(k) == expected);

}

lock.lock();

checksum += evector->get(0);

lock.unlock();

}

// Modify vertex data by adding values there */

chivector<size_t> * vvector = vertex.get_vector();

int numitems = vertex.id() % 10;

for(int i=0; i<numitems; i++) {

vvector->add(vertex.id() * 982192l + i); // Arbitrary

}

/* Check vertex data immediatelly */

for(int i=0; i<numitems; i++) {

size_t x = vvector->get(i);

size_t expected = vertex.id() * 982192l + i;

assert(x == expected);

}

}

/**

void before_iteration(int iteration, graphchi_context &gcontext) {

}

/**

void after_iteration(int iteration, graphchi_context &gcontext) {

}

/**

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

}

/**

void after_exec_interval(vid_t window_st, vid_t window_en, graphchi_context &gcontext) {

}

std::cout << "Generating data..." << std::endl;

const char * fname = filename.c_str();

FILE * f = fopen(fname, "w");

set_conf("filetype", "edgelist");

shouldbe = 0;

int totalVertices = 200000; // 2 million

for(int i=0; i < totalVertices; i++) {

int nedges = random() % 50;

for(int j=0; j < nedges; j++) {

int dst = (totalVertices / nedges) * j + i % nedges;

if (dst != i) {

if ((i + dst) % 3 == 1) {

fprintf(f, "%d\t%d\t%d:%d:%d\n", i, dst, i + dst, i + dst + 1, i + dst + 2);

} else {

fprintf(f, "%d\t%d\t%d\n", i, dst, i + dst);

}

shouldbe += 2 * (i + dst);

}

}

}

fclose(f);

virtual void callback(vid_t vertex_id, chivector<size_t> &vec) {

int numitems = vertex_id % 10;

assert(vec.size() == numitems);

for(int j=0; j < numitems; j++) {

size_t x = vec.get(j);

assert(x == vertex_id * 982192l + (size_t)j);

}

}

/* GraphChi initialization will read the command line

graphchi_init(argc, argv);

/* Metrics object for keeping track of performance counters

metrics m("test-dynamicedata");

/* Basic arguments for application */

std::string filename = "/tmp/__chi_dyntest/testgraph"; // Base filename

mkdir("/tmp/__chi_dyntest", 0777);

int niters = 1; // Number of iterations

bool scheduler = false; // Whether to use selective scheduling

/* Generate data */

generatedata(filename);

set_conf("filetype", "multivalueedgelist");

int nshards = convert_if_notexists<vid_t>(filename, "3");

checksum = 0;

/* Run */

DynamicDataLoaderTestProgram program;

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

engine.set_reset_vertexdata(true);

engine.run(program, niters);

/* Check */

std::cout << "Checksum: " << checksum << ", expecting: " << shouldbe << std::endl;

assert(shouldbe == checksum);

/* Check vertex values */

VertexValidator validator;

foreach_vertices(filename, 0, engine.num_vertices(), validator);

/* Clean up */

delete_shards<EdgeDataType>(filename, 3);

/* Report execution metrics */

metrics_report(m);

logstream(LOG_INFO) << "Test passed successfully! Your system is working!" << std::endl;

return 0;