| // Copyright (C) 2005-2006 The Trustees of Indiana University. |
| // Use, modification and distribution is subject to the Boost Software |
| // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| // Authors: Peter Gottschling |
| // Douglas Gregor |
| // Andrew Lumsdaine |
| |
| #include <boost/graph/iteration_macros.hpp> |
| #include <boost/property_map/parallel/global_index_map.hpp> |
| |
| #ifndef BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE |
| #define BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE |
| |
| #ifndef BOOST_GRAPH_USE_MPI |
| #error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included" |
| #endif |
| |
| namespace boost { namespace graph { |
| |
| template <class Property, class Graph> |
| void property_on_inedges(Property p, const Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) |
| BGL_FORALL_INEDGES_T(u, e, g, Graph) |
| request(p, e); |
| synchronize(p); |
| } |
| |
| // For reverse graphs |
| template <class Property, class Graph> |
| void property_on_outedges(Property p, const Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| request(p, e); |
| synchronize(p); |
| } |
| |
| template <class Property, class Graph> |
| void property_on_successors(Property p, const Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| request(p, target(e, g)); |
| synchronize(p); |
| } |
| |
| template <class Property, class Graph> |
| void property_on_predecessors(Property p, const Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) |
| BGL_FORALL_INEDGES_T(u, e, g, Graph) |
| request(p, source(e, g)); |
| synchronize(p); |
| } |
| |
| // Like successors and predecessors but saves one synchronize (and a call) |
| template <class Property, class Graph> |
| void property_on_adjacents(Property p, const Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) { |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| request(p, target(e, g)); |
| BGL_FORALL_INEDGES_T(u, e, g, Graph) |
| request(p, source(e, g)); |
| } |
| synchronize(p); |
| } |
| |
| template <class PropertyIn, class PropertyOut, class Graph> |
| void copy_vertex_property(PropertyIn p_in, PropertyOut p_out, Graph& g) |
| { |
| BGL_FORALL_VERTICES_T(u, g, Graph) |
| put(p_out, u, get(p_in, g)); |
| } |
| |
| template <class PropertyIn, class PropertyOut, class Graph> |
| void copy_edge_property(PropertyIn p_in, PropertyOut p_out, Graph& g) |
| { |
| BGL_FORALL_EDGES_T(e, g, Graph) |
| put(p_out, e, get(p_in, g)); |
| } |
| |
| |
| namespace distributed { |
| |
| // Define global_index<Graph> global(graph); |
| // Then global(v) returns global index of v |
| template <typename Graph> |
| struct global_index |
| { |
| typedef typename property_map<Graph, vertex_index_t>::const_type |
| VertexIndexMap; |
| typedef typename property_map<Graph, vertex_global_t>::const_type |
| VertexGlobalMap; |
| |
| explicit global_index(Graph const& g) |
| : global_index_map(process_group(g), num_vertices(g), get(vertex_index, g), |
| get(vertex_global, g)) {} |
| |
| int operator() (typename graph_traits<Graph>::vertex_descriptor v) |
| { return get(global_index_map, v); } |
| |
| protected: |
| boost::parallel::global_index_map<VertexIndexMap, VertexGlobalMap> |
| global_index_map; |
| }; |
| |
| template<typename T> |
| struct additive_reducer { |
| BOOST_STATIC_CONSTANT(bool, non_default_resolver = true); |
| |
| template<typename K> |
| T operator()(const K&) const { return T(0); } |
| |
| template<typename K> |
| T operator()(const K&, const T& local, const T& remote) const { return local + remote; } |
| }; |
| |
| template <typename T> |
| struct choose_min_reducer { |
| BOOST_STATIC_CONSTANT(bool, non_default_resolver = true); |
| |
| template<typename K> |
| T operator()(const K&) const { return (std::numeric_limits<T>::max)(); } |
| |
| template<typename K> |
| T operator()(const K&, const T& x, const T& y) const |
| { return x < y ? x : y; } |
| }; |
| |
| // To use a property map syntactically like a function |
| template <typename PropertyMap> |
| struct property_map_reader |
| { |
| explicit property_map_reader(PropertyMap pm) : pm(pm) {} |
| |
| template <typename T> |
| typename PropertyMap::value_type |
| operator() (const T& v) |
| { |
| return get(pm, v); |
| } |
| private: |
| PropertyMap pm; |
| }; |
| |
| } // namespace distributed |
| |
| }} // namespace boost::graph |
| |
| #endif // BOOST_GRAPH_DISTRIBUTED_GRAPH_UTILITY_INCLUDE |