155 lines
4.5 KiB
C++
155 lines
4.5 KiB
C++
// 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
|