void generate_random_graph
(MutableGraph& g,
typename graph_traits<MutableGraph>::vertices_size_type V,
typename graph_traits<MutableGraph>::vertices_size_type E,
RandNumGen& gen,
VertexOutputIterator vertex_out,
EdgeOutputIterator edge_out,
bool self_edges = false)
{
typedef graph_traits<MutableGraph> Traits;
typedef typename Traits::vertices_size_type v_size_t;
typedef typename Traits::edges_size_type e_size_t;
typedef typename Traits::vertex_descriptor vertex_t;
typedef typename Traits::edge_descriptor edge_t;
for (v_size_t i = 0; i < V; ++i)
*vertex_out++ = add_vertex(g);
for (e_size_t j = 0; j < E; ++j) {
vertex_t a = random_vertex(g, gen), b;
do {
b = random_vertex(g, gen);
} while (self_edges == false && a == b);
edge_t e; bool inserted;
tie(e, inserted) = add_edge(a, b, g);
if (inserted)
*edge_out++ = std::make_pair(source(e, g), target(e, g));
}
}
/*
* Test hash consing: add a random triple in table
*/
static void test_random_triple(dl_vartable_t *table) {
dl_triple_t *check;
dl_triple_t test;
int32_t x, y;
test.target = random_vertex(6);
test.source = random_vertex(6);
q_init(&test.constant);
random_rational(&test.constant);
if (test.target == test.source) {
test.target = nil_vertex;
test.source = nil_vertex;
}
printf("Test: add triple ");
print_dl_triple(&test);
printf("\n");
x = get_dl_var(table, &test);
printf(" ---> var = %"PRId32"\n", x);
check = dl_var_triple(table, x);
if (check->target == test.target &&
check->source == test.source &&
q_eq(&check->constant, &test.constant)) {
printf("Checking descriptor: OK\n");
} else {
printf("BUG: invalid descriptor for var %"PRId32"\n", x);
fflush(stdout);
exit(1);
}
y = get_dl_var(table, &test);
if (x == y) {
printf("Checking hash-consing: OK\n");
} else {
printf("BUG: hash-consing fails for var %"PRId32"\n", x);
fflush(stdout);
exit(1);
}
printf("\n");
q_clear(&test.constant);
}
void generate_random_graph1
(MutableGraph& g,
typename graph_traits<MutableGraph>::vertices_size_type V,
typename graph_traits<MutableGraph>::vertices_size_type E,
RandNumGen& gen,
bool allow_parallel = true,
bool self_edges = false)
{
typedef graph_traits<MutableGraph> Traits;
typedef typename Traits::vertices_size_type v_size_t;
typedef typename Traits::edges_size_type e_size_t;
typedef typename Traits::vertex_descriptor vertex_descriptor;
// When parallel edges are not allowed, we create a new graph which
// does not allow parallel edges, construct it and copy back.
// This is not efficient if 'g' already disallow parallel edges,
// but that's task for later.
if (!allow_parallel) {
typedef typename boost::graph_traits<MutableGraph>::directed_category dir;
typedef typename mpl::if_<is_convertible<dir, directed_tag>,
directedS, undirectedS>::type select;
adjacency_list<setS, vecS, select> g2;
generate_random_graph1(g2, V, E, gen, true, self_edges);
copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()).
edge_copy(detail::dummy_property_copier()));
} else {
for (v_size_t i = 0; i < V; ++i)
add_vertex(g);
for (e_size_t j = 0; j < E; ++j) {
vertex_descriptor a = random_vertex(g, gen), b;
do {
b = random_vertex(g, gen);
} while (self_edges == false && a == b);
add_edge(a, b, g);
}
}
}
void generate_random_graph
(MutableGraph& g,
typename graph_traits<MutableGraph>::vertices_size_type V,
typename graph_traits<MutableGraph>::vertices_size_type E,
RandNumGen& gen,
bool self_edges = false)
{
typedef graph_traits<MutableGraph> Traits;
typedef typename Traits::vertices_size_type v_size_t;
typedef typename Traits::edges_size_type e_size_t;
typedef typename Traits::vertex_descriptor vertex_descriptor;
for (v_size_t i = 0; i < V; ++i)
add_vertex(g);
for (e_size_t j = 0; j < E; ++j) {
vertex_descriptor a = random_vertex(g, gen), b;
do {
b = random_vertex(g, gen);
} while (self_edges == false && a == b);
add_edge(a, b, g);
}
}
int main(int argc,
char *argv[])
{
size_t num_edges;
aligned_t * rets;
vertex_t * edges;
for (int i = 0; i < NUM_VERTICES; i++) {
in_degrees[i] = 0;
}
/* Initialize SPR in SPMD mode */
qthread_f actions[2] = {incr_in_degree, NULL};
spr_init(SPR_SPMD, actions);
here = spr_locale_id();
num_locales = spr_num_locales();
if (0 == here) {
printf("Running with %d locales\n", num_locales);
}
rng_init(rng_state.state, time(NULL) * here);
/* Create local portion of the graph */
indices[0] = 0;
for (int i = 1; i < NUM_VERTICES + 1; i++) {
indices[i] = indices[i-1] + random_vertex();
}
for (int i = 0; i < NUM_VERTICES + 1; i++) {
printf("[%03d] indices[%d]: %lu\n", here, i, indices[i]);
}
num_edges = indices[NUM_VERTICES];
edges = malloc(num_edges * sizeof(vertex_t));
for (int i = 0; i < num_edges; i++) {
edges[i].lid = random_locale();
edges[i].vid = random_vertex();
}
for (int i = 0; i < num_edges; i++) {
printf("[%03d] edges[%d]: (%lu,%lu)\n", here, i,
edges[i].lid, edges[i].vid);
}
/* TODO: barrier */
/* Fill in-degrees property map */
rets = malloc(num_edges * sizeof(aligned_t));
for (int i = 0; i < NUM_VERTICES; i++) {
for (int j = indices[i]; j < indices[i+1]; j++) {
printf("[%03d] spawning incr of edge[%d] = (%lu,%lu)\n",
here, j, edges[j].lid, edges[j].vid);
qthread_fork_remote(incr_in_degree, /* action */
&(edges[j].vid), /* local vertex id */
&rets[j], /* feb */
edges[j].lid, /* locale */
sizeof(vertex_id_t));
}
}
for (int i = 0; i < num_edges; i++) {
qthread_readFF(&rets[i], &rets[i]);
}
/* Print in-degrees */
for (int i = 0; i < NUM_VERTICES; i++) {
printf("[%03d] in-degree(%lu) = %lu\n",
here, i, in_degrees[i]);
}
/* Free up allocated resources */
free(rets);
free(edges);
return 0;
}
