/* This version is for sequential machines, OpenMP, and the XMT. */
void scramble_edges_shared(uint64_t userseed1, uint64_t userseed2, int64_t nedges, int64_t* result /* Input and output array of edges (size = 2 * nedges) */) {
mrg_state st;
uint_fast32_t seed[5];
int64_t* new_result;
int64_t i;
int64_t* perm = (int64_t*)xmalloc(nedges * sizeof(int64_t));
make_mrg_seed(userseed1, userseed2, seed);
mrg_seed(&st, seed);
mrg_skip(&st, 5, 0, 0); /* To make offset different from other PRNG uses */
rand_sort_shared(&st, nedges, perm);
new_result = (int64_t*)xmalloc(nedges * 2 * sizeof(int64_t));
#ifdef __MTA__
#pragma mta assert parallel
#pragma mta block schedule
#endif
#ifdef GRAPH_GENERATOR_OMP
#pragma omp parallel for
#endif
for (i = 0; i < nedges; ++i) {
int64_t p = perm[i];
new_result[i * 2 + 0] = result[p * 2 + 0];
new_result[i * 2 + 1] = result[p * 2 + 1];
}
free(perm);
memcpy(result, new_result, nedges * 2 * sizeof(int64_t));
free(new_result);
}
/* PRNG interface for implementations; takes seed in same format as given by
* users, and creates a vector of doubles in a reproducible (and
* random-access) way. */
void make_random_numbers(
/* in */ int64_t nvalues /* Number of values to generate */,
/* in */ uint64_t userseed1 /* Arbitrary 64-bit seed value */,
/* in */ uint64_t userseed2 /* Arbitrary 64-bit seed value */,
/* in */ int64_t position /* Start index in random number stream */,
/* out */ double* result /* Returned array of values */
) {
int64_t i;
uint_fast32_t seed[5];
make_mrg_seed(userseed1, userseed2, seed);
mrg_state st;
mrg_seed(&st, seed);
mrg_skip(&st, 2, 0, 2 * position); /* Each double takes two PRNG outputs */
for (i = 0; i < nvalues; ++i) {
result[i] = mrg_get_double_orig(&st);
}
}
/* For MPI distributed memory. */
void scramble_edges_mpi(MPI_Comm comm,
const uint64_t userseed1, const uint64_t userseed2,
const int64_t local_nedges_in,
const int64_t* const local_edges_in,
int64_t* const local_nedges_out_ptr,
int64_t** const local_edges_out_ptr /* Allocated using xmalloc() by scramble_edges_mpi */) {
int rank, size;
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &size);
mrg_state st;
uint_fast32_t seed[5];
make_mrg_seed(userseed1, userseed2, seed);
mrg_seed(&st, seed);
mrg_skip(&st, 5, 0, 0); /* To make offset different from other PRNG uses */
int64_t total_nedges;
MPI_Allreduce((void*)&local_nedges_in, &total_nedges, 1, INT64_T_MPI_TYPE, MPI_SUM, comm);
int64_t local_nedges_out; /* = local permutation size */
int64_t* local_perm;
rand_sort_mpi(comm, &st, total_nedges, &local_nedges_out, &local_perm);
*local_nedges_out_ptr = local_nedges_out;
/* Gather permutation information and fast owner lookup cache (code in
* apply_permutation_mpi.c). */
int64_t* edge_displs = (int64_t*)xmalloc((size + 1) * sizeof(int64_t));
int* edge_owner_table;
int64_t* edge_owner_cutoff;
int lg_minedgecount;
int64_t maxedgecount;
gather_block_distribution_info(comm, local_nedges_in, total_nedges, edge_displs, &edge_owner_table, &edge_owner_cutoff, &lg_minedgecount, &maxedgecount);
/* Originally from apply_permutation_mpi.c */
#define LOOKUP_EDGE_OWNER(v) \
(edge_owner_table[(v) >> lg_minedgecount] + \
((v) >= edge_owner_cutoff[(v) >> lg_minedgecount]))
/* Apply permutation. Output distribution is same as distribution of
* generated edge permutation. */
/* Count number of requests to send to each destination. */
int* send_counts = (int*)xcalloc(size, sizeof(int)); /* Uses zero-init */
int64_t i;
for (i = 0; i < local_nedges_out; ++i) {
++send_counts[LOOKUP_EDGE_OWNER(local_perm[i])];
}
/* Prefix sum to get displacements. */
int* send_displs = (int*)xmalloc((size + 1) * sizeof(int));
send_displs[0] = 0;
for (i = 0; i < size; ++i) {
send_displs[i + 1] = send_displs[i] + send_counts[i];
}
assert (send_displs[size] == local_nedges_out);
/* Put edges into buffer by destination; also keep around index values for
* where to write the result. */
int64_t* sendbuf = (int64_t*)xmalloc(local_nedges_out * sizeof(int64_t));
int64_t* reply_loc_buf = (int64_t*)xmalloc(local_nedges_out * sizeof(int64_t));
int* send_offsets = (int*)xmalloc((size + 1) * sizeof(int));
memcpy(send_offsets, send_displs, (size + 1) * sizeof(int));
for (i = 0; i < local_nedges_out; ++i) {
int write_index = send_offsets[LOOKUP_EDGE_OWNER(local_perm[i])];
sendbuf[write_index] = local_perm[i];
reply_loc_buf[write_index] = i;
++send_offsets[LOOKUP_EDGE_OWNER(local_perm[i])];
}
for (i = 0; i < size; ++i) assert (send_offsets[i] == send_displs[i + 1]);
free(send_offsets); send_offsets = NULL;
free(local_perm); local_perm = NULL;
#undef LOOKUP_EDGE_OWNER
free(edge_owner_table); edge_owner_table = NULL;
free(edge_owner_cutoff); edge_owner_cutoff = NULL;
/* Find out how many requests I will be receiving. */
int* recv_counts = (int*)xmalloc(size * sizeof(int));
MPI_Alltoall(send_counts, 1, MPI_INT,
recv_counts, 1, MPI_INT,
comm);
/* Compute their displacements. */
int* recv_displs = (int*)xmalloc((size + 1) * sizeof(int));
recv_displs[0] = 0;
for (i = 0; i < size; ++i) {
recv_displs[i + 1] = recv_displs[i] + recv_counts[i];
}
/* Make receive and reply buffers. */
int64_t* recvbuf = (int64_t*)xmalloc(recv_displs[size] * sizeof(int64_t));
int64_t* replybuf = (int64_t*)xmalloc(recv_displs[size] * 2 * sizeof(int64_t));
/* Move requests for edges into receive buffer. */
MPI_Alltoallv(sendbuf, send_counts, send_displs, INT64_T_MPI_TYPE,
recvbuf, recv_counts, recv_displs, INT64_T_MPI_TYPE,
comm);
free(sendbuf); sendbuf = NULL;
/* Put requested edges into response buffer. */
int64_t my_edge_offset = edge_displs[rank];
for (i = 0; i < recv_displs[size]; ++i) {
replybuf[i * 2 + 0] = local_edges_in[(recvbuf[i] - my_edge_offset) * 2 + 0];
replybuf[i * 2 + 1] = local_edges_in[(recvbuf[i] - my_edge_offset) * 2 + 1];
}
free(recvbuf); recvbuf = NULL;
free(edge_displs); edge_displs = NULL;
/* Send replies back. */
int64_t* reply_edges = (int64_t*)xmalloc(local_nedges_out * 2 * sizeof(int64_t));
for (i = 0; i < size; ++i) { /* Sending back two values for each request */
recv_counts[i] *= 2;
recv_displs[i] *= 2;
send_counts[i] *= 2;
send_displs[i] *= 2;
}
MPI_Alltoallv(replybuf, recv_counts, recv_displs, INT64_T_MPI_TYPE,
reply_edges, send_counts, send_displs, INT64_T_MPI_TYPE,
comm);
free(replybuf); replybuf = NULL;
free(recv_counts); recv_counts = NULL;
free(recv_displs); recv_displs = NULL;
free(send_counts); send_counts = NULL;
free(send_displs); send_displs = NULL;
/* Make output array of edges. */
int64_t* local_edges_out = (int64_t*)xmalloc(local_nedges_out * 2 * sizeof(int64_t));
*local_edges_out_ptr = local_edges_out;
/* Put edges into output array. */
for (i = 0; i < local_nedges_out; ++i) {
local_edges_out[reply_loc_buf[i] * 2 + 0] = reply_edges[2 * i + 0];
local_edges_out[reply_loc_buf[i] * 2 + 1] = reply_edges[2 * i + 1];
}
free(reply_loc_buf); reply_loc_buf = NULL;
free(reply_edges); reply_edges = NULL;
}
int main(int argc, char** argv)
{
struct options options;
if (process_options(argc, argv, true, &options) != 0)
return 0;
if (options.rmat.a + options.rmat.b + options.rmat.c >= 1) {
printf("Error: The sum of probabilities must equal 1\n");
return 0;
}
double d = 1 - (options.rmat.a + options.rmat.b + options.rmat.c);
xscale_node = options.rmat.xscale_node;
xscale_interval = options.rmat.xscale_interval;
uint_fast32_t seed[5];
make_mrg_seed(options.rng.userseed1, options.rng.userseed2, seed);
mrg_state state;
mrg_seed(&state, seed);
//mrg_skip(&new_state, 50, 7, 0); // Do an initial skip?
edge_t total_edges = options.rmat.edges;
if((total_edges % options.rmat.xscale_interval) > options.rmat.xscale_node) {
total_edges /= options.rmat.xscale_interval;
total_edges++;
}
else {
total_edges /= options.rmat.xscale_interval;
}
if (options.global.symmetric) {
total_edges *= 2;
}
printf("Generator type: R-MAT\n");
printf("Scale: %d (%" PRIu64 " vertices)\n", options.rmat.scale, ((uint64_t)1 << options.rmat.scale));
printf("Edges: %" PRIet "\n", total_edges);
printf("Probabilities: A=%4.2f, B=%4.2f, C=%4.2f, D=%4.2f\n", options.rmat.a, options.rmat.b, options.rmat.c, d);
double start = get_time();
// io thread
size_t buffer_size = calculate_buffer_size(options.global.buffer_size);
buffer_queue flushq;
buffer_manager manager(&flushq, options.global.buffers_per_thread, buffer_size);
io_thread_func io_func(options.global.graphname.c_str(), total_edges, &flushq, &manager, buffer_size);
boost::thread io_thread(boost::ref(io_func));
// worker threads
int nthreads = options.global.nthreads;
edge_t edges_per_thread = options.rmat.edges / nthreads;
threadid_t* workers[nthreads];
boost::thread* worker_threads[nthreads];
for (int i = 0; i < nthreads; i++) {
workers[i] = new threadid_t(i);
thread_buffer* buffer = manager.register_thread(*workers[i]);
// last thread gets the remainder (if any)
edge_t start = i * edges_per_thread;
edge_t end = (i == nthreads-1) ? (options.rmat.edges) : ((i+1) * edges_per_thread);
worker_threads[i] = new boost::thread(generate, buffer,
state, options.rmat.scale, start, end,
options.rmat.a, options.rmat.b, options.rmat.c, /*d,*/
options.global.symmetric);
}
// Wait until work completes
for (int i = 0; i < nthreads; i++) {
worker_threads[i]->join();
}
io_func.stop();
io_thread.join();
// cleanup
for (int i = 0; i < nthreads; i++) {
manager.unregister_thread(*workers[i]);
delete worker_threads[i];
delete workers[i];
}
double elapsed = get_time() - start;
printf("Generation time: %fs\n", elapsed);
make_ini_file(options.global.graphname.c_str(), (uint64_t)1 << options.rmat.scale, total_edges);
return 0;
}
void make_graph(int log_numverts, int64_t desired_nedges, uint64_t userseed1, uint64_t userseed2, const double initiator[4], int64_t* nedges_ptr, int64_t** result_ptr) {
int64_t N, M;
/* Spread the two 64-bit numbers into five nonzero values in the correct
* range. */
uint_fast32_t seed[5];
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
generated_edge* edges;
#else
int64_t* edges;
#endif
int64_t nedges;
int64_t* vertex_perm;
int64_t* result;
int64_t i;
mrg_state state;
int64_t v1;
int64_t v2;
N = (int64_t)pow(GRAPHGEN_INITIATOR_SIZE, log_numverts);
M = desired_nedges;
make_mrg_seed(userseed1, userseed2, seed);
nedges = compute_edge_array_size(0, 1, M);
*nedges_ptr = nedges;
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
edges = (generated_edge*)xcalloc(nedges, sizeof(generated_edge)); /* multiplicity set to 0 for unused edges */
#else
edges = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
#endif
generate_kronecker(0, 1, seed, log_numverts, M, initiator, edges);
vertex_perm = (int64_t*)xmalloc(N * sizeof(int64_t));
/* result; AL: this is a needless warning about unused code. */
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
result = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
#else
result = edges;
#endif
*result_ptr = result;
mrg_seed(&state, seed);
rand_sort_shared(&state, N, vertex_perm);
/* Apply vertex permutation to graph, optionally copying into user's result
* array. */
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
for (i = 0; i < nedges; ++i) {
if (edges[i].multiplicity != 0) {
v1 = vertex_perm[edges[i].src];
v2 = vertex_perm[edges[i].tgt];
/* Sort these since otherwise the directions of the permuted edges would
* give away the unscrambled vertex order. */
result[i * 2] = (v1 < v2) ? v1 : v2;
result[i * 2 + 1] = (v1 < v2) ? v2 : v1;
} else {
result[i * 2] = result[i * 2 + 1] = (int64_t)(-1);
}
}
free(edges);
#else
for (i = 0; i < 2 * nedges; i += 2) {
if (edges[i] != (int64_t)(-1)) {
v1 = vertex_perm[edges[i]];
v2 = vertex_perm[edges[i + 1]];
/* Sort these since otherwise the directions of the permuted edges would
* give away the unscrambled vertex order. */
edges[i] = (v1 < v2) ? v1 : v2;
edges[i + 1] = (v1 < v2) ? v2 : v1;
}
}
#endif
free(vertex_perm);
/* Randomly mix up the order of the edges. */
scramble_edges_shared(userseed1, userseed2, nedges, edges);
}
void make_graph(int log_numverts, int64_t desired_nedges, uint64_t userseed1, uint64_t userseed2, const double initiator[4], int64_t* nedges_ptr, int64_t** result_ptr) {
int64_t N, M;
int rank, size;
N = (int64_t)pow(GRAPHGEN_INITIATOR_SIZE, log_numverts);
M = desired_nedges;
/* Spread the two 64-bit numbers into five nonzero values in the correct
* range. */
uint_fast32_t seed[5];
make_mrg_seed(userseed1, userseed2, seed);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
int64_t nedges = compute_edge_array_size(rank, size, M);
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
generated_edge* local_edges = (generated_edge*)xmalloc(nedges * sizeof(generated_edge));
#else
int64_t* local_edges = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
#endif
double start = MPI_Wtime();
generate_kronecker(rank, size, seed, log_numverts, M, initiator, local_edges);
double gen_time = MPI_Wtime() - start;
int64_t* local_vertex_perm = NULL;
mrg_state state;
mrg_seed(&state, seed);
start = MPI_Wtime();
int64_t perm_local_size;
rand_sort_mpi(MPI_COMM_WORLD, &state, N, &perm_local_size, &local_vertex_perm);
double perm_gen_time = MPI_Wtime() - start;
/* Copy the edge endpoints into the result array if necessary. */
int64_t* result;
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
result = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
for (i = 0; i < nedges; ++i) {
if (local_edges[i].multiplicity != 0) {
result[i * 2] = local_edges[i].src;
result[i * 2 + 1] = local_edges[i].tgt;
} else {
result[i * 2] = result[i * 2 + 1] = (int64_t)(-1);
}
}
free(local_edges); local_edges = NULL;
#else
result = local_edges;
*result_ptr = result;
local_edges = NULL; /* Freed by caller */
#endif
/* Apply vertex permutation to graph. */
start = MPI_Wtime();
apply_permutation_mpi(MPI_COMM_WORLD, perm_local_size, local_vertex_perm, N, nedges, result);
double perm_apply_time = MPI_Wtime() - start;
free(local_vertex_perm); local_vertex_perm = NULL;
/* Randomly mix up the order of the edges. */
start = MPI_Wtime();
int64_t* new_result;
int64_t nedges_out;
scramble_edges_mpi(MPI_COMM_WORLD, userseed1, userseed2, nedges, result, &nedges_out, &new_result);
double edge_scramble_time = MPI_Wtime() - start;
free(result); result = NULL;
*result_ptr = new_result;
*nedges_ptr = nedges_out;
if (rank == 0) {
fprintf(stdout, "unpermuted_graph_generation: %f s\n", gen_time);
fprintf(stdout, "vertex_permutation_generation: %f s\n", perm_gen_time);
fprintf(stdout, "vertex_permutation_application: %f s\n", perm_apply_time);
fprintf(stdout, "edge_scrambling: %f s\n", edge_scramble_time);
}
}
void make_graph(int log_numverts, int64_t desired_nedges, uint64_t userseed1, uint64_t userseed2, const double initiator[4], int64_t* nedges_ptr, int64_t** result_ptr) {
int64_t N, M;
N = (int64_t)pow(GRAPHGEN_INITIATOR_SIZE, log_numverts);
M = (int64_t)desired_nedges;
/* Spread the two 64-bit numbers into five nonzero values in the correct
* range. */
uint_fast32_t seed[5];
make_mrg_seed(userseed1, userseed2, seed);
int64_t nedges = compute_edge_array_size(0, 1, M);
*nedges_ptr = nedges;
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
generated_edge* edges = (generated_edge*)xcalloc(nedges, sizeof(generated_edge)); /* multiplicity set to 0 for unused edges */
#else
int64_t* edges = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
#endif
int rank, size;
/* The "for all streams" here is in compiler versions >= 6.4 */
#pragma mta use 100 streams
#pragma mta for all streams rank of size
{
double my_initiator[GRAPHGEN_INITIATOR_SIZE * GRAPHGEN_INITIATOR_SIZE]; /* Local copy */
int i;
for (i = 0; i < GRAPHGEN_INITIATOR_SIZE * GRAPHGEN_INITIATOR_SIZE; ++i) {
my_initiator[i] = initiator[i];
}
generate_kronecker(rank, size, seed, log_numverts, M, my_initiator, edges);
}
int64_t* vertex_perm = (int64_t*)xmalloc(N * sizeof(int64_t));
int64_t* result;
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
result = (int64_t*)xmalloc(2 * nedges * sizeof(int64_t));
#else
result = edges;
#endif
*result_ptr = result;
mrg_state state;
mrg_seed(&state, seed);
rand_sort_shared(&state, N, vertex_perm);
int64_t i;
/* Apply vertex permutation to graph, optionally copying into user's result
* array. */
#ifdef GRAPHGEN_KEEP_MULTIPLICITIES
#pragma mta assert parallel
#pragma mta block schedule
for (i = 0; i < nedges; ++i) {
if (edges[i].multiplicity != 0) {
int64_t v1 = vertex_perm[edges[i].src];
int64_t v2 = vertex_perm[edges[i].tgt];
/* Sort these since otherwise the directions of the permuted edges would
* give away the unscrambled vertex order. */
result[i * 2] = MTA_INT_MIN(v1, v2);
result[i * 2 + 1] = MTA_INT_MAX(v1, v2);
} else {
result[i * 2] = result[i * 2 + 1] = (int64_t)(-1);
}
}
free(edges);
#else
#pragma mta assert parallel
#pragma mta block schedule
for (i = 0; i < 2 * nedges; i += 2) {
if (edges[i] != (int64_t)(-1)) {
int64_t v1 = vertex_perm[edges[i]];
int64_t v2 = vertex_perm[edges[i + 1]];
/* Sort these since otherwise the directions of the permuted edges would
* give away the unscrambled vertex order. */
edges[i] = MTA_INT_MIN(v1, v2);
edges[i + 1] = MTA_INT_MAX(v1, v2);
}
}
#endif
free(vertex_perm);
/* Randomly mix up the order of the edges. */
scramble_edges_shared(userseed1, userseed2, nedges, edges);
}
