1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// 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
|
