You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
154 lines
4.5 KiB
154 lines
4.5 KiB
// 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
|
|
|