void prepare_injective_join(LeftEmitKey left_emit_key,
RightEmitKey right_emit_key) {
typedef std::pair<size_t, vertex_id_type> key_vertex_pair;
// Basically, what we are trying to do is to figure out, for each vertex
// on one side of the graph, which vertices for the other graph
// (and on on which machines) emitted the same key.
//
// The target datastructure is:
// vtx_to_key[vtx]: The key for each vertex
// opposing_join_proc[vtx]: Machines which hold a vertex on the opposing
// graph which emitted the same key
// key_to_vtx[key] Mapping of keys to vertices.
// resize the left index
// resize the right index
reset_and_fill_injective_index(left_inj_index,
left_graph,
left_emit_key, "left graph");
reset_and_fill_injective_index(right_inj_index,
right_graph,
right_emit_key, "right graph");
rmi.barrier();
// now, we need cross join across all machines to figure out the
// opposing join proc
// we need to do this twice. Once for left, and once for right.
compute_injective_join();
}
void run_synchronous(MemberFunction member_fun, const vertex_set& vset) {
shared_lvid_counter = 0;
if (threads.size() <= 1) {
(this->*(member_fun))(0, vset);
}
else {
// launch the initialization threads
for(size_t i = 0; i < threads.size(); ++i) {
boost::function<void(void)> invoke = boost::bind(member_fun, this, i, vset);
threads.launch(invoke, i);
}
}
// Wait for all threads to finish
threads.join();
rmi.barrier();
} // end of run_synchronous
/**
Must be called by all machines simultaneously
*/
void clear() {
rpc.barrier();
storage.clear();
}
/// \copydoc distributed_control::barrier()
inline void barrier() {
rmi.barrier();
}