| // Copyright 2004 The Trustees of Indiana University. |
| |
| // Distributed under 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: Douglas Gregor |
| // Andrew Lumsdaine |
| #ifndef BOOST_GRAPH_PARALLEL_BRANDES_BETWEENNESS_CENTRALITY_HPP |
| #define BOOST_GRAPH_PARALLEL_BRANDES_BETWEENNESS_CENTRALITY_HPP |
| |
| #ifndef BOOST_GRAPH_USE_MPI |
| #error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included" |
| #endif |
| |
| // #define COMPUTE_PATH_COUNTS_INLINE |
| |
| #include <boost/graph/betweenness_centrality.hpp> |
| #include <boost/graph/overloading.hpp> |
| #include <boost/graph/distributed/concepts.hpp> |
| #include <boost/graph/graph_traits.hpp> |
| #include <boost/config.hpp> |
| |
| // For additive_reducer |
| #include <boost/graph/distributed/distributed_graph_utility.hpp> |
| #include <boost/type_traits/is_convertible.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/property_map/property_map.hpp> |
| #include <boost/graph/named_function_params.hpp> |
| |
| #include <boost/property_map/parallel/distributed_property_map.hpp> |
| #include <boost/graph/distributed/detail/dijkstra_shortest_paths.hpp> |
| #include <boost/tuple/tuple.hpp> |
| |
| // NGE - Needed for minstd_rand at L807, should pass vertex list |
| // or generator instead |
| #include <boost/random/linear_congruential.hpp> |
| |
| #include <algorithm> |
| #include <stack> |
| #include <vector> |
| |
| // Appending reducer |
| template <typename T> |
| struct append_reducer { |
| BOOST_STATIC_CONSTANT(bool, non_default_resolver = true); |
| |
| template<typename K> |
| T operator()(const K&) const { return T(); } |
| |
| template<typename K> |
| T operator()(const K&, const T& x, const T& y) const |
| { |
| T z(x.begin(), x.end()); |
| for (typename T::const_iterator iter = y.begin(); iter != y.end(); ++iter) |
| if (std::find(z.begin(), z.end(), *iter) == z.end()) |
| z.push_back(*iter); |
| |
| return z; |
| } |
| }; |
| |
| namespace boost { |
| |
| namespace serialization { |
| |
| // TODO(nge): Write generalized serialization for tuples |
| template<typename Archive, typename T1, typename T2, typename T3, |
| typename T4> |
| void serialize(Archive & ar, |
| boost::tuple<T1,T2,T3, T4>& t, |
| const unsigned int) |
| { |
| ar & get<0>(t); |
| ar & get<1>(t); |
| ar & get<2>(t); |
| ar & get<3>(t); |
| } |
| |
| } // serialization |
| |
| template <typename OwnerMap, typename Tuple> |
| class get_owner_of_first_tuple_element { |
| |
| public: |
| typedef typename property_traits<OwnerMap>::value_type owner_type; |
| |
| get_owner_of_first_tuple_element(OwnerMap owner) : owner(owner) { } |
| |
| owner_type get_owner(Tuple t) { return boost::get(owner, get<0>(t)); } |
| |
| private: |
| OwnerMap owner; |
| }; |
| |
| template <typename OwnerMap, typename Tuple> |
| typename get_owner_of_first_tuple_element<OwnerMap, Tuple>::owner_type |
| get(get_owner_of_first_tuple_element<OwnerMap, Tuple> o, Tuple t) |
| { return o.get_owner(t); } |
| |
| template <typename OwnerMap> |
| class get_owner_of_first_pair_element { |
| |
| public: |
| typedef typename property_traits<OwnerMap>::value_type owner_type; |
| |
| get_owner_of_first_pair_element(OwnerMap owner) : owner(owner) { } |
| |
| template <typename Vertex, typename T> |
| owner_type get_owner(std::pair<Vertex, T> p) { return get(owner, p.first); } |
| |
| private: |
| OwnerMap owner; |
| }; |
| |
| template <typename OwnerMap, typename Vertex, typename T> |
| typename get_owner_of_first_pair_element<OwnerMap>::owner_type |
| get(get_owner_of_first_pair_element<OwnerMap> o, std::pair<Vertex, T> p) |
| { return o.get_owner(p); } |
| |
| namespace graph { namespace parallel { namespace detail { |
| |
| template<typename DistanceMap, typename IncomingMap> |
| class betweenness_centrality_msg_value |
| { |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| typedef typename property_traits<IncomingMap>::value_type incoming_type; |
| typedef typename incoming_type::value_type incoming_value_type; |
| |
| public: |
| typedef std::pair<distance_type, incoming_value_type> type; |
| |
| static type create(distance_type dist, incoming_value_type source) |
| { return std::make_pair(dist, source); } |
| }; |
| |
| |
| /************************************************************************/ |
| /* Delta-stepping Betweenness Centrality */ |
| /************************************************************************/ |
| |
| template<typename Graph, typename DistanceMap, typename IncomingMap, |
| typename EdgeWeightMap, typename PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , typename IsSettledMap, typename VertexIndexMap |
| #endif |
| > |
| class betweenness_centrality_delta_stepping_impl { |
| // Could inherit from delta_stepping_impl to get run() method |
| // but for the time being it's just reproduced here |
| |
| typedef typename graph_traits<Graph>::vertex_descriptor Vertex; |
| typedef typename graph_traits<Graph>::degree_size_type Degree; |
| typedef typename property_traits<EdgeWeightMap>::value_type Dist; |
| typedef typename property_traits<IncomingMap>::value_type IncomingType; |
| typedef typename boost::graph::parallel::process_group_type<Graph>::type |
| ProcessGroup; |
| |
| typedef std::list<Vertex> Bucket; |
| typedef typename Bucket::iterator BucketIterator; |
| typedef typename std::vector<Bucket*>::size_type BucketIndex; |
| |
| typedef betweenness_centrality_msg_value<DistanceMap, IncomingMap> |
| MessageValue; |
| |
| enum { |
| // Relax a remote vertex. The message contains a pair<Vertex, |
| // MessageValue>, the first part of which is the vertex whose |
| // tentative distance is being relaxed and the second part |
| // contains either the new distance (if there is no predecessor |
| // map) or a pair with the distance and predecessor. |
| msg_relax |
| }; |
| |
| public: |
| |
| // Must supply delta, ctor that guesses delta removed |
| betweenness_centrality_delta_stepping_impl(const Graph& g, |
| DistanceMap distance, |
| IncomingMap incoming, |
| EdgeWeightMap weight, |
| PathCountMap path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| IsSettledMap is_settled, |
| VertexIndexMap vertex_index, |
| #endif |
| Dist delta); |
| |
| void run(Vertex s); |
| |
| private: |
| // Relax the edge (u, v), creating a new best path of distance x. |
| void relax(Vertex u, Vertex v, Dist x); |
| |
| // Synchronize all of the processes, by receiving all messages that |
| // have not yet been received. |
| void synchronize() |
| { |
| using boost::graph::parallel::synchronize; |
| synchronize(pg); |
| } |
| |
| // Setup triggers for msg_relax messages |
| void setup_triggers() |
| { |
| using boost::graph::parallel::simple_trigger; |
| simple_trigger(pg, msg_relax, this, |
| &betweenness_centrality_delta_stepping_impl::handle_msg_relax); |
| } |
| |
| void handle_msg_relax(int /*source*/, int /*tag*/, |
| const std::pair<Vertex, typename MessageValue::type>& data, |
| trigger_receive_context) |
| { relax(data.second.second, data.first, data.second.first); } |
| |
| const Graph& g; |
| IncomingMap incoming; |
| DistanceMap distance; |
| EdgeWeightMap weight; |
| PathCountMap path_count; |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| IsSettledMap is_settled; |
| VertexIndexMap vertex_index; |
| #endif |
| Dist delta; |
| ProcessGroup pg; |
| typename property_map<Graph, vertex_owner_t>::const_type owner; |
| typename property_map<Graph, vertex_local_t>::const_type local; |
| |
| // A "property map" that contains the position of each vertex in |
| // whatever bucket it resides in. |
| std::vector<BucketIterator> position_in_bucket; |
| |
| // Bucket data structure. The ith bucket contains all local vertices |
| // with (tentative) distance in the range [i*delta, |
| // (i+1)*delta). |
| std::vector<Bucket*> buckets; |
| |
| // This "dummy" list is used only so that we can initialize the |
| // position_in_bucket property map with non-singular iterators. This |
| // won't matter for most implementations of the C++ Standard |
| // Library, but it avoids undefined behavior and allows us to run |
| // with library "debug modes". |
| std::list<Vertex> dummy_list; |
| |
| // A "property map" that states which vertices have been deleted |
| // from the bucket in this iteration. |
| std::vector<bool> vertex_was_deleted; |
| }; |
| |
| template<typename Graph, typename DistanceMap, typename IncomingMap, |
| typename EdgeWeightMap, typename PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , typename IsSettledMap, typename VertexIndexMap |
| #endif |
| > |
| betweenness_centrality_delta_stepping_impl< |
| Graph, DistanceMap, IncomingMap, EdgeWeightMap, PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , IsSettledMap, VertexIndexMap |
| #endif |
| >:: |
| betweenness_centrality_delta_stepping_impl(const Graph& g, |
| DistanceMap distance, |
| IncomingMap incoming, |
| EdgeWeightMap weight, |
| PathCountMap path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| IsSettledMap is_settled, |
| VertexIndexMap vertex_index, |
| #endif |
| Dist delta) |
| : g(g), |
| incoming(incoming), |
| distance(distance), |
| weight(weight), |
| path_count(path_count), |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| is_settled(is_settled), |
| vertex_index(vertex_index), |
| #endif |
| delta(delta), |
| pg(boost::graph::parallel::process_group_adl(g), attach_distributed_object()), |
| owner(get(vertex_owner, g)), |
| local(get(vertex_local, g)) |
| |
| { setup_triggers(); } |
| |
| template<typename Graph, typename DistanceMap, typename IncomingMap, |
| typename EdgeWeightMap, typename PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , typename IsSettledMap, typename VertexIndexMap |
| #endif |
| > |
| void |
| betweenness_centrality_delta_stepping_impl< |
| Graph, DistanceMap, IncomingMap, EdgeWeightMap, PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , IsSettledMap, VertexIndexMap |
| #endif |
| >:: |
| run(Vertex s) |
| { |
| typedef typename boost::graph::parallel::process_group_type<Graph>::type |
| process_group_type; |
| typename process_group_type::process_id_type id = process_id(pg); |
| |
| Dist inf = (std::numeric_limits<Dist>::max)(); |
| |
| // None of the vertices are stored in the bucket. |
| position_in_bucket.clear(); |
| position_in_bucket.resize(num_vertices(g), dummy_list.end()); |
| |
| // None of the vertices have been deleted |
| vertex_was_deleted.clear(); |
| vertex_was_deleted.resize(num_vertices(g), false); |
| |
| // No path from s to any other vertex, yet |
| BGL_FORALL_VERTICES_T(v, g, Graph) |
| put(distance, v, inf); |
| |
| // The distance to the starting node is zero |
| if (get(owner, s) == id) |
| // Put "s" into its bucket (bucket 0) |
| relax(s, s, 0); |
| else |
| // Note that we know the distance to s is zero |
| cache(distance, s, 0); |
| |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| // Synchronize here to deliver initial relaxation since we don't |
| // synchronize at the beginning of the inner loop any more |
| synchronize(); |
| |
| // Incoming edge count map is an implementation detail and should |
| // be freed as soon as possible so build it here |
| typedef typename graph_traits<Graph>::edges_size_type edges_size_type; |
| |
| std::vector<edges_size_type> incoming_edge_countS(num_vertices(g)); |
| iterator_property_map<typename std::vector<edges_size_type>::iterator, VertexIndexMap> |
| incoming_edge_count(incoming_edge_countS.begin(), vertex_index); |
| #endif |
| |
| BucketIndex max_bucket = (std::numeric_limits<BucketIndex>::max)(); |
| BucketIndex current_bucket = 0; |
| do { |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| // We need to clear the outgoing map after every bucket so just build it here |
| std::vector<IncomingType> outgoingS(num_vertices(g)); |
| IncomingMap outgoing(outgoingS.begin(), vertex_index); |
| |
| outgoing.set_reduce(append_reducer<IncomingType>()); |
| #else |
| // Synchronize with all of the other processes. |
| synchronize(); |
| #endif |
| |
| // Find the next bucket that has something in it. |
| while (current_bucket < buckets.size() |
| && (!buckets[current_bucket] || buckets[current_bucket]->empty())) |
| ++current_bucket; |
| if (current_bucket >= buckets.size()) |
| current_bucket = max_bucket; |
| |
| // Find the smallest bucket (over all processes) that has vertices |
| // that need to be processed. |
| using boost::parallel::all_reduce; |
| using boost::parallel::minimum; |
| current_bucket = all_reduce(pg, current_bucket, minimum<BucketIndex>()); |
| |
| if (current_bucket == max_bucket) |
| // There are no non-empty buckets in any process; exit. |
| break; |
| |
| // Contains the set of vertices that have been deleted in the |
| // relaxation of "light" edges. Note that we keep track of which |
| // vertices were deleted with the property map |
| // "vertex_was_deleted". |
| std::vector<Vertex> deleted_vertices; |
| |
| // Repeatedly relax light edges |
| bool nonempty_bucket; |
| do { |
| // Someone has work to do in this bucket. |
| |
| if (current_bucket < buckets.size() && buckets[current_bucket]) { |
| Bucket& bucket = *buckets[current_bucket]; |
| // For each element in the bucket |
| while (!bucket.empty()) { |
| Vertex u = bucket.front(); |
| |
| // Remove u from the front of the bucket |
| bucket.pop_front(); |
| |
| // Insert u into the set of deleted vertices, if it hasn't |
| // been done already. |
| if (!vertex_was_deleted[get(local, u)]) { |
| vertex_was_deleted[get(local, u)] = true; |
| deleted_vertices.push_back(u); |
| } |
| |
| // Relax each light edge. |
| Dist u_dist = get(distance, u); |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| if (get(weight, e) <= delta) // light edge |
| relax(u, target(e, g), u_dist + get(weight, e)); |
| } |
| } |
| |
| // Synchronize with all of the other processes. |
| synchronize(); |
| |
| // Is the bucket empty now? |
| nonempty_bucket = (current_bucket < buckets.size() |
| && buckets[current_bucket] |
| && !buckets[current_bucket]->empty()); |
| } while (all_reduce(pg, nonempty_bucket, std::logical_or<bool>())); |
| |
| // Relax heavy edges for each of the vertices that we previously |
| // deleted. |
| for (typename std::vector<Vertex>::iterator iter = deleted_vertices.begin(); |
| iter != deleted_vertices.end(); ++iter) { |
| // Relax each heavy edge. |
| Vertex u = *iter; |
| Dist u_dist = get(distance, u); |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| if (get(weight, e) > delta) // heavy edge |
| relax(u, target(e, g), u_dist + get(weight, e)); |
| |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| // Set outgoing paths |
| IncomingType in = get(incoming, u); |
| for (typename IncomingType::iterator pred = in.begin(); pred != in.end(); ++pred) |
| if (get(owner, *pred) == id) { |
| IncomingType x = get(outgoing, *pred); |
| if (std::find(x.begin(), x.end(), u) == x.end()) |
| x.push_back(u); |
| put(outgoing, *pred, x); |
| } else { |
| IncomingType in; |
| in.push_back(u); |
| put(outgoing, *pred, in); |
| } |
| |
| // Set incoming edge counts |
| put(incoming_edge_count, u, in.size()); |
| #endif |
| } |
| |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| synchronize(); // Deliver heavy edge relaxations and outgoing paths |
| |
| // Build Queue |
| typedef typename property_traits<PathCountMap>::value_type PathCountType; |
| typedef std::pair<Vertex, PathCountType> queue_value_type; |
| typedef typename property_map<Graph, vertex_owner_t>::const_type OwnerMap; |
| typedef typename get_owner_of_first_pair_element<OwnerMap> IndirectOwnerMap; |
| |
| typedef boost::queue<queue_value_type> local_queue_type; |
| typedef boost::graph::distributed::distributed_queue<process_group_type, |
| IndirectOwnerMap, |
| local_queue_type> dist_queue_type; |
| |
| IndirectOwnerMap indirect_owner(owner); |
| dist_queue_type Q(pg, indirect_owner); |
| |
| // Find sources to initialize queue |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| if (get(is_settled, v) && !(get(outgoing, v).empty())) { |
| put(incoming_edge_count, v, 1); |
| Q.push(std::make_pair(v, 0)); // Push this vertex with no additional path count |
| } |
| } |
| |
| // Set path counts for vertices in this bucket |
| while (!Q.empty()) { |
| queue_value_type t = Q.top(); Q.pop(); |
| Vertex v = t.first; |
| PathCountType p = t.second; |
| |
| put(path_count, v, get(path_count, v) + p); |
| put(incoming_edge_count, v, get(incoming_edge_count, v) - 1); |
| |
| if (get(incoming_edge_count, v) == 0) { |
| IncomingType out = get(outgoing, v); |
| for (typename IncomingType::iterator iter = out.begin(); iter != out.end(); ++iter) |
| Q.push(std::make_pair(*iter, get(path_count, v))); |
| } |
| } |
| |
| // Mark the vertices in this bucket settled |
| for (typename std::vector<Vertex>::iterator iter = deleted_vertices.begin(); |
| iter != deleted_vertices.end(); ++iter) |
| put(is_settled, *iter, true); |
| |
| // No need to clear path count map as it is never read/written remotely |
| // No need to clear outgoing map as it is re-alloced every bucket |
| #endif |
| |
| // Go to the next bucket: the current bucket must already be empty. |
| ++current_bucket; |
| } while (true); |
| |
| // Delete all of the buckets. |
| for (typename std::vector<Bucket*>::iterator iter = buckets.begin(); |
| iter != buckets.end(); ++iter) { |
| if (*iter) { |
| delete *iter; |
| *iter = 0; |
| } |
| } |
| } |
| |
| template<typename Graph, typename DistanceMap, typename IncomingMap, |
| typename EdgeWeightMap, typename PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , typename IsSettledMap, typename VertexIndexMap |
| #endif |
| > |
| void |
| betweenness_centrality_delta_stepping_impl< |
| Graph, DistanceMap, IncomingMap, EdgeWeightMap, PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , IsSettledMap, VertexIndexMap |
| #endif |
| >:: |
| relax(Vertex u, Vertex v, Dist x) |
| { |
| |
| if (x <= get(distance, v)) { |
| |
| // We're relaxing the edge to vertex v. |
| if (get(owner, v) == process_id(pg)) { |
| if (x < get(distance, v)) { |
| // Compute the new bucket index for v |
| BucketIndex new_index = static_cast<BucketIndex>(x / delta); |
| |
| // Make sure there is enough room in the buckets data structure. |
| if (new_index >= buckets.size()) buckets.resize(new_index + 1, 0); |
| |
| // Make sure that we have allocated the bucket itself. |
| if (!buckets[new_index]) buckets[new_index] = new Bucket; |
| |
| if (get(distance, v) != (std::numeric_limits<Dist>::max)() |
| && !vertex_was_deleted[get(local, v)]) { |
| // We're moving v from an old bucket into a new one. Compute |
| // the old index, then splice it in. |
| BucketIndex old_index |
| = static_cast<BucketIndex>(get(distance, v) / delta); |
| buckets[new_index]->splice(buckets[new_index]->end(), |
| *buckets[old_index], |
| position_in_bucket[get(local, v)]); |
| } else { |
| // We're inserting v into a bucket for the first time. Put it |
| // at the end. |
| buckets[new_index]->push_back(v); |
| } |
| |
| // v is now at the last position in the new bucket |
| position_in_bucket[get(local, v)] = buckets[new_index]->end(); |
| --position_in_bucket[get(local, v)]; |
| |
| // Update tentative distance information and incoming, path_count |
| if (u != v) put(incoming, v, IncomingType(1, u)); |
| put(distance, v, x); |
| } // u != v covers initial source relaxation and self-loops |
| else if (x == get(distance, v) && u != v) { |
| |
| // Add incoming edge if it's not already in the list |
| IncomingType in = get(incoming, v); |
| if (std::find(in.begin(), in.end(), u) == in.end()) { |
| in.push_back(u); |
| put(incoming, v, in); |
| } |
| } |
| } else { |
| // The vertex is remote: send a request to the vertex's owner |
| send(pg, get(owner, v), msg_relax, |
| std::make_pair(v, MessageValue::create(x, u))); |
| |
| // Cache tentative distance information |
| cache(distance, v, x); |
| } |
| } |
| } |
| |
| /************************************************************************/ |
| /* Shortest Paths function object for betweenness centrality */ |
| /************************************************************************/ |
| |
| template<typename WeightMap> |
| struct brandes_shortest_paths { |
| typedef typename property_traits<WeightMap>::value_type weight_type; |
| |
| brandes_shortest_paths() |
| : weight(1), delta(0) { } |
| brandes_shortest_paths(weight_type delta) |
| : weight(1), delta(delta) { } |
| brandes_shortest_paths(WeightMap w) |
| : weight(w), delta(0) { } |
| brandes_shortest_paths(WeightMap w, weight_type delta) |
| : weight(w), delta(delta) { } |
| |
| template<typename Graph, typename IncomingMap, typename DistanceMap, |
| typename PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , typename IsSettledMap, typename VertexIndexMap |
| #endif |
| |
| > |
| void |
| operator()(Graph& g, |
| typename graph_traits<Graph>::vertex_descriptor s, |
| IncomingMap incoming, |
| DistanceMap distance, |
| PathCountMap path_count |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , IsSettledMap is_settled, |
| VertexIndexMap vertex_index |
| #endif |
| ) |
| { |
| typedef typename property_traits<DistanceMap>::value_type |
| distance_type; |
| |
| typedef std::plus<distance_type> Combine; |
| typedef std::less<distance_type> Compare; |
| |
| // The "distance" map needs to act like one, retrieving the default |
| // value of infinity. |
| set_property_map_role(vertex_distance, distance); |
| |
| // Only calculate delta the first time operator() is called |
| // This presumes g is the same every time, but so does the fact |
| // that we're reusing the weight map |
| if (delta == 0) |
| set_delta(g); |
| |
| // TODO (NGE): Restructure the code so we don't have to construct |
| // impl every time? |
| betweenness_centrality_delta_stepping_impl< |
| Graph, DistanceMap, IncomingMap, WeightMap, PathCountMap |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , IsSettledMap, VertexIndexMap |
| #endif |
| > |
| impl(g, distance, incoming, weight, path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| is_settled, vertex_index, |
| #endif |
| delta); |
| |
| impl.run(s); |
| } |
| |
| private: |
| |
| template <typename Graph> |
| void |
| set_delta(const Graph& g) |
| { |
| using boost::parallel::all_reduce; |
| using boost::parallel::maximum; |
| using std::max; |
| |
| typedef typename graph_traits<Graph>::degree_size_type Degree; |
| typedef weight_type Dist; |
| |
| // Compute the maximum edge weight and degree |
| Dist max_edge_weight = 0; |
| Degree max_degree = 0; |
| BGL_FORALL_VERTICES_T(u, g, Graph) { |
| max_degree = max BOOST_PREVENT_MACRO_SUBSTITUTION (max_degree, out_degree(u, g)); |
| BGL_FORALL_OUTEDGES_T(u, e, g, Graph) |
| max_edge_weight = max BOOST_PREVENT_MACRO_SUBSTITUTION (max_edge_weight, get(weight, e)); |
| } |
| |
| max_edge_weight = all_reduce(process_group(g), max_edge_weight, maximum<Dist>()); |
| max_degree = all_reduce(process_group(g), max_degree, maximum<Degree>()); |
| |
| // Take a guess at delta, based on what works well for random |
| // graphs. |
| delta = max_edge_weight / max_degree; |
| if (delta == 0) |
| delta = 1; |
| } |
| |
| WeightMap weight; |
| weight_type delta; |
| }; |
| |
| // Perform a single SSSP from the specified vertex and update the centrality map(s) |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, typename DependencyMap, |
| typename PathCountMap, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| typename IsSettledMap, |
| #endif |
| typename VertexIndexMap, typename ShortestPaths> |
| void |
| do_brandes_sssp(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| IsSettledMap is_settled, |
| #endif |
| VertexIndexMap vertex_index, |
| ShortestPaths shortest_paths, |
| typename graph_traits<Graph>::vertex_descriptor s) |
| { |
| using boost::detail::graph::update_centrality; |
| using boost::graph::parallel::process_group; |
| |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; |
| typedef typename graph_traits<Graph>::edges_size_type edges_size_type; |
| |
| typedef typename property_traits<IncomingMap>::value_type incoming_type; |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| typedef typename property_traits<DependencyMap>::value_type dependency_type; |
| typedef typename property_traits<PathCountMap>::value_type path_count_type; |
| |
| typedef typename incoming_type::iterator incoming_iterator; |
| |
| typedef typename property_map<Graph, vertex_owner_t>::const_type OwnerMap; |
| OwnerMap owner = get(vertex_owner, g); |
| |
| typedef typename boost::graph::parallel::process_group_type<Graph>::type |
| process_group_type; |
| process_group_type pg = process_group(g); |
| typename process_group_type::process_id_type id = process_id(pg); |
| |
| // TODO: Is it faster not to clear some of these maps? |
| // Initialize for this iteration |
| distance.clear(); |
| incoming.clear(); |
| path_count.clear(); |
| dependency.clear(); |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| put(path_count, v, 0); |
| put(dependency, v, 0); |
| } |
| |
| if (get(owner, s) == id) { |
| put(incoming, s, incoming_type()); |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| put(path_count, s, 1); |
| put(is_settled, s, true); |
| #endif |
| } |
| |
| // Execute the shortest paths algorithm. This will be either |
| // a weighted or unweighted customized breadth-first search, |
| shortest_paths(g, s, incoming, distance, path_count |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| , is_settled, vertex_index |
| #endif |
| ); |
| |
| #ifndef COMPUTE_PATH_COUNTS_INLINE |
| |
| // |
| // TODO: Optimize case where source has no out-edges |
| // |
| |
| // Count of incoming edges to tell when all incoming edges have been relaxed in |
| // the induced shortest paths DAG |
| std::vector<edges_size_type> incoming_edge_countS(num_vertices(g)); |
| iterator_property_map<typename std::vector<edges_size_type>::iterator, VertexIndexMap> |
| incoming_edge_count(incoming_edge_countS.begin(), vertex_index); |
| |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| put(incoming_edge_count, v, get(incoming, v).size()); |
| } |
| |
| if (get(owner, s) == id) { |
| put(incoming_edge_count, s, 1); |
| put(incoming, s, incoming_type()); |
| } |
| |
| std::vector<incoming_type> outgoingS(num_vertices(g)); |
| iterator_property_map<typename std::vector<incoming_type>::iterator, VertexIndexMap> |
| outgoing(outgoingS.begin(), vertex_index); |
| |
| outgoing.set_reduce(append_reducer<incoming_type>()); |
| |
| // Mark forward adjacencies in DAG of shortest paths |
| |
| // TODO: It's possible to do this using edge flags but it's not currently done this way |
| // because during traversal of the DAG we would have to examine all out edges |
| // which would lead to more memory accesses and a larger cache footprint. |
| // |
| // In the bidirectional graph case edge flags would be an excellent way of marking |
| // edges in the DAG of shortest paths |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| incoming_type i = get(incoming, v); |
| for (typename incoming_type::iterator iter = i.begin(); iter != i.end(); ++iter) { |
| if (get(owner, *iter) == id) { |
| incoming_type x = get(outgoing, *iter); |
| if (std::find(x.begin(), x.end(), v) == x.end()) |
| x.push_back(v); |
| put(outgoing, *iter, x); |
| } else { |
| incoming_type in; |
| in.push_back(v); |
| put(outgoing, *iter, in); |
| } |
| } |
| } |
| |
| synchronize(pg); |
| |
| // Traverse DAG induced by forward edges in dependency order and compute path counts |
| { |
| typedef std::pair<vertex_descriptor, path_count_type> queue_value_type; |
| typedef get_owner_of_first_pair_element<OwnerMap> IndirectOwnerMap; |
| |
| typedef boost::queue<queue_value_type> local_queue_type; |
| typedef boost::graph::distributed::distributed_queue<process_group_type, |
| IndirectOwnerMap, |
| local_queue_type> dist_queue_type; |
| |
| IndirectOwnerMap indirect_owner(owner); |
| dist_queue_type Q(pg, indirect_owner); |
| |
| if (get(owner, s) == id) |
| Q.push(std::make_pair(s, 1)); |
| |
| while (!Q.empty()) { |
| queue_value_type t = Q.top(); Q.pop(); |
| vertex_descriptor v = t.first; |
| path_count_type p = t.second; |
| |
| put(path_count, v, get(path_count, v) + p); |
| put(incoming_edge_count, v, get(incoming_edge_count, v) - 1); |
| |
| if (get(incoming_edge_count, v) == 0) { |
| incoming_type out = get(outgoing, v); |
| for (typename incoming_type::iterator iter = out.begin(); iter != out.end(); ++iter) |
| Q.push(std::make_pair(*iter, get(path_count, v))); |
| } |
| } |
| } |
| |
| #endif // COMPUTE_PATH_COUNTS_INLINE |
| |
| // |
| // Compute dependencies |
| // |
| |
| |
| // Build the distributed_queue |
| // Value type consists of 1) target of update 2) source of update |
| // 3) dependency of source 4) path count of source |
| typedef boost::tuple<vertex_descriptor, vertex_descriptor, dependency_type, path_count_type> |
| queue_value_type; |
| typedef get_owner_of_first_tuple_element<OwnerMap, queue_value_type> IndirectOwnerMap; |
| |
| typedef boost::queue<queue_value_type> local_queue_type; |
| typedef boost::graph::distributed::distributed_queue<process_group_type, |
| IndirectOwnerMap, |
| local_queue_type> dist_queue_type; |
| |
| IndirectOwnerMap indirect_owner(owner); |
| dist_queue_type Q(pg, indirect_owner); |
| |
| // Calculate number of vertices each vertex depends on, when a vertex has been pushed |
| // that number of times then we will update it |
| // AND Request path counts of sources of incoming edges |
| std::vector<dependency_type> dependency_countS(num_vertices(g), 0); |
| iterator_property_map<typename std::vector<dependency_type>::iterator, VertexIndexMap> |
| dependency_count(dependency_countS.begin(), vertex_index); |
| |
| dependency_count.set_reduce(boost::graph::distributed::additive_reducer<dependency_type>()); |
| |
| path_count.set_max_ghost_cells(0); |
| |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| if (get(distance, v) < (std::numeric_limits<distance_type>::max)()) { |
| incoming_type el = get(incoming, v); |
| for (incoming_iterator vw = el.begin(); vw != el.end(); ++vw) { |
| if (get(owner, *vw) == id) |
| put(dependency_count, *vw, get(dependency_count, *vw) + 1); |
| else { |
| put(dependency_count, *vw, 1); |
| |
| // Request path counts |
| get(path_count, *vw); |
| } |
| |
| // request() doesn't work here, perhaps because we don't have a copy of this |
| // ghost cell already? |
| } |
| } |
| } |
| |
| synchronize(pg); |
| |
| // Push vertices with non-zero distance/path count and zero dependency count |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| if (get(distance, v) < (std::numeric_limits<distance_type>::max)() |
| && get(dependency_count, v) == 0) |
| Q.push(boost::make_tuple(v, v, get(dependency, v), get(path_count, v))); |
| } |
| |
| dependency.set_max_ghost_cells(0); |
| while(!Q.empty()) { |
| |
| queue_value_type x = Q.top(); Q.pop(); |
| vertex_descriptor w = get<0>(x); |
| vertex_descriptor source = get<1>(x); |
| dependency_type dep = get<2>(x); |
| path_count_type pc = get<3>(x); |
| |
| cache(dependency, source, dep); |
| cache(path_count, source, pc); |
| |
| if (get(dependency_count, w) != 0) |
| put(dependency_count, w, get(dependency_count, w) - 1); |
| |
| if (get(dependency_count, w) == 0) { |
| |
| // Update dependency and centrality of sources of incoming edges |
| incoming_type el = get(incoming, w); |
| for (incoming_iterator vw = el.begin(); vw != el.end(); ++vw) { |
| vertex_descriptor v = *vw; |
| |
| assert(get(path_count, w) != 0); |
| |
| dependency_type factor = dependency_type(get(path_count, v)) |
| / dependency_type(get(path_count, w)); |
| factor *= (dependency_type(1) + get(dependency, w)); |
| |
| if (get(owner, v) == id) |
| put(dependency, v, get(dependency, v) + factor); |
| else |
| put(dependency, v, factor); |
| |
| update_centrality(edge_centrality_map, v, factor); |
| } |
| |
| if (w != s) |
| update_centrality(centrality, w, get(dependency, w)); |
| |
| // Push sources of edges in incoming edge list |
| for (incoming_iterator vw = el.begin(); vw != el.end(); ++vw) |
| Q.push(boost::make_tuple(*vw, w, get(dependency, w), get(path_count, w))); |
| } |
| } |
| } |
| |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, typename DependencyMap, |
| typename PathCountMap, typename VertexIndexMap, typename ShortestPaths, |
| typename Buffer> |
| void |
| brandes_betweenness_centrality_impl(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| ShortestPaths shortest_paths, |
| Buffer sources) |
| { |
| using boost::detail::graph::init_centrality_map; |
| using boost::detail::graph::divide_centrality_by_two; |
| using boost::graph::parallel::process_group; |
| |
| typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; |
| typedef typename graph_traits<Graph>::edge_iterator edge_iterator; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type; |
| |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| typedef typename property_traits<DependencyMap>::value_type dependency_type; |
| |
| // Initialize centrality |
| init_centrality_map(vertices(g), centrality); |
| init_centrality_map(edges(g), edge_centrality_map); |
| |
| // Set the reduction operation on the dependency map to be addition |
| dependency.set_reduce(boost::graph::distributed::additive_reducer<dependency_type>()); |
| distance.set_reduce(boost::graph::distributed::choose_min_reducer<distance_type>()); |
| |
| // Don't allow remote procs to write incoming or path_count maps |
| // updating them is handled inside the betweenness_centrality_queue |
| incoming.set_consistency_model(0); |
| path_count.set_consistency_model(0); |
| |
| typedef typename boost::graph::parallel::process_group_type<Graph>::type |
| process_group_type; |
| process_group_type pg = process_group(g); |
| |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| // Build is_settled maps |
| std::vector<bool> is_settledS(num_vertices(g)); |
| typedef iterator_property_map<std::vector<bool>::iterator, VertexIndexMap> |
| IsSettledMap; |
| |
| IsSettledMap is_settled(is_settledS.begin(), vertex_index); |
| #endif |
| |
| if (!sources.empty()) { |
| // DO SSSPs |
| while (!sources.empty()) { |
| do_brandes_sssp(g, centrality, edge_centrality_map, incoming, distance, |
| dependency, path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| is_settled, |
| #endif |
| vertex_index, shortest_paths, sources.top()); |
| sources.pop(); |
| } |
| } else { // Exact Betweenness Centrality |
| typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type; |
| vertices_size_type n = num_vertices(g); |
| n = boost::parallel::all_reduce(pg, n, std::plus<vertices_size_type>()); |
| |
| for (vertices_size_type i = 0; i < n; ++i) { |
| vertex_descriptor v = vertex(i, g); |
| |
| do_brandes_sssp(g, centrality, edge_centrality_map, incoming, distance, |
| dependency, path_count, |
| #ifdef COMPUTE_PATH_COUNTS_INLINE |
| is_settled, |
| #endif |
| vertex_index, shortest_paths, v); |
| } |
| } |
| |
| typedef typename graph_traits<Graph>::directed_category directed_category; |
| const bool is_undirected = |
| is_convertible<directed_category*, undirected_tag*>::value; |
| if (is_undirected) { |
| divide_centrality_by_two(vertices(g), centrality); |
| divide_centrality_by_two(edges(g), edge_centrality_map); |
| } |
| } |
| |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, typename DependencyMap, |
| typename PathCountMap, typename VertexIndexMap, typename ShortestPaths, |
| typename Stack> |
| void |
| do_sequential_brandes_sssp(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| ShortestPaths shortest_paths, |
| Stack& ordered_vertices, |
| typename graph_traits<Graph>::vertex_descriptor v) |
| { |
| using boost::detail::graph::update_centrality; |
| |
| typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| |
| typedef typename property_traits<IncomingMap>::value_type incoming_type; |
| |
| // Initialize for this iteration |
| BGL_FORALL_VERTICES_T(w, g, Graph) { |
| // put(path_count, w, 0); |
| incoming[w].clear(); |
| put(dependency, w, 0); |
| } |
| |
| put(path_count, v, 1); |
| incoming[v].clear(); |
| |
| // Execute the shortest paths algorithm. This will be either |
| // Dijkstra's algorithm or a customized breadth-first search, |
| // depending on whether the graph is weighted or unweighted. |
| shortest_paths(g, v, ordered_vertices, incoming, distance, |
| path_count, vertex_index); |
| |
| while (!ordered_vertices.empty()) { |
| vertex_descriptor w = ordered_vertices.top(); |
| ordered_vertices.pop(); |
| |
| typedef typename property_traits<IncomingMap>::value_type |
| incoming_type; |
| typedef typename incoming_type::iterator incoming_iterator; |
| typedef typename property_traits<DependencyMap>::value_type |
| dependency_type; |
| |
| for (incoming_iterator vw = incoming[w].begin(); |
| vw != incoming[w].end(); ++vw) { |
| vertex_descriptor v = source(*vw, g); |
| dependency_type factor = dependency_type(get(path_count, v)) |
| / dependency_type(get(path_count, w)); |
| factor *= (dependency_type(1) + get(dependency, w)); |
| put(dependency, v, get(dependency, v) + factor); |
| update_centrality(edge_centrality_map, *vw, factor); |
| } |
| |
| if (w != v) { |
| update_centrality(centrality, w, get(dependency, w)); |
| } |
| } |
| } |
| |
| // Betweenness Centrality variant that duplicates graph across processors |
| // and parallizes SSSPs |
| // This function expects a non-distributed graph and property-maps |
| template<typename ProcessGroup, typename Graph, |
| typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, |
| typename DependencyMap, typename PathCountMap, |
| typename VertexIndexMap, typename ShortestPaths, |
| typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality_impl(const ProcessGroup& pg, |
| const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, // P |
| DistanceMap distance, // d |
| DependencyMap dependency, // delta |
| PathCountMap path_count, // sigma |
| VertexIndexMap vertex_index, |
| ShortestPaths shortest_paths, |
| Buffer sources) |
| { |
| using boost::detail::graph::init_centrality_map; |
| using boost::detail::graph::divide_centrality_by_two; |
| using boost::graph::parallel::process_group; |
| |
| typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; |
| typedef typename graph_traits<Graph>::edge_iterator edge_iterator; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type; |
| |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| |
| typedef ProcessGroup process_group_type; |
| |
| typename process_group_type::process_id_type id = process_id(pg); |
| typename process_group_type::process_size_type p = num_processes(pg); |
| |
| // Initialize centrality |
| init_centrality_map(vertices(g), centrality); |
| init_centrality_map(edges(g), edge_centrality_map); |
| |
| std::stack<vertex_descriptor> ordered_vertices; |
| |
| if (!sources.empty()) { |
| std::vector<vertex_descriptor> local_sources; |
| |
| for (int i = 0; i < id; ++i) if (!sources.empty()) sources.pop(); |
| while (!sources.empty()) { |
| local_sources.push_back(sources.top()); |
| |
| for (int i = 0; i < p; ++i) if (!sources.empty()) sources.pop(); |
| } |
| |
| // DO SSSPs |
| for(size_t i = 0; i < local_sources.size(); ++i) |
| do_sequential_brandes_sssp(g, centrality, edge_centrality_map, incoming, |
| distance, dependency, path_count, vertex_index, |
| shortest_paths, ordered_vertices, local_sources[i]); |
| |
| } else { // Exact Betweenness Centrality |
| typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type; |
| vertices_size_type n = num_vertices(g); |
| |
| for (vertices_size_type i = id; i < n; i += p) { |
| vertex_descriptor v = vertex(i, g); |
| |
| do_sequential_brandes_sssp(g, centrality, edge_centrality_map, incoming, |
| distance, dependency, path_count, vertex_index, |
| shortest_paths, ordered_vertices, v); |
| } |
| } |
| |
| typedef typename graph_traits<Graph>::directed_category directed_category; |
| const bool is_undirected = |
| is_convertible<directed_category*, undirected_tag*>::value; |
| if (is_undirected) { |
| divide_centrality_by_two(vertices(g), centrality); |
| divide_centrality_by_two(edges(g), edge_centrality_map); |
| } |
| |
| // Merge the centrality maps by summing the values at each vertex) |
| // TODO(nge): this copy-out, reduce, copy-in is lame |
| typedef typename property_traits<CentralityMap>::value_type centrality_type; |
| typedef typename property_traits<EdgeCentralityMap>::value_type edge_centrality_type; |
| |
| std::vector<centrality_type> centrality_v(num_vertices(g)); |
| std::vector<edge_centrality_type> edge_centrality_v; |
| edge_centrality_v.reserve(num_edges(g)); |
| |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| centrality_v[get(vertex_index, v)] = get(centrality, v); |
| } |
| |
| // Skip when EdgeCentralityMap is a dummy_property_map |
| if (!is_same<EdgeCentralityMap, dummy_property_map>::value) { |
| BGL_FORALL_EDGES_T(e, g, Graph) { |
| edge_centrality_v.push_back(get(edge_centrality_map, e)); |
| } |
| // NGE: If we trust that the order of elements in the vector isn't changed in the |
| // all_reduce below then this method avoids the need for an edge index map |
| } |
| |
| using boost::parallel::all_reduce; |
| |
| all_reduce(pg, ¢rality_v[0], ¢rality_v[centrality_v.size()], |
| ¢rality_v[0], std::plus<centrality_type>()); |
| |
| if (edge_centrality_v.size()) |
| all_reduce(pg, &edge_centrality_v[0], &edge_centrality_v[edge_centrality_v.size()], |
| &edge_centrality_v[0], std::plus<edge_centrality_type>()); |
| |
| BGL_FORALL_VERTICES_T(v, g, Graph) { |
| put(centrality, v, centrality_v[get(vertex_index, v)]); |
| } |
| |
| // Skip when EdgeCentralityMap is a dummy_property_map |
| if (!is_same<EdgeCentralityMap, dummy_property_map>::value) { |
| int i = 0; |
| BGL_FORALL_EDGES_T(e, g, Graph) { |
| put(edge_centrality_map, e, edge_centrality_v[i]); |
| ++i; |
| } |
| } |
| } |
| |
| } } } // end namespace graph::parallel::detail |
| |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, typename DependencyMap, |
| typename PathCountMap, typename VertexIndexMap, typename Buffer> |
| void |
| brandes_betweenness_centrality(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| Buffer sources, |
| typename property_traits<DistanceMap>::value_type delta |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| typedef static_property_map<distance_type> WeightMap; |
| |
| graph::parallel::detail::brandes_shortest_paths<WeightMap> |
| shortest_paths(delta); |
| |
| graph::parallel::detail::brandes_betweenness_centrality_impl(g, centrality, |
| edge_centrality_map, |
| incoming, distance, |
| dependency, path_count, |
| vertex_index, |
| shortest_paths, |
| sources); |
| } |
| |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename IncomingMap, typename DistanceMap, typename DependencyMap, |
| typename PathCountMap, typename VertexIndexMap, typename WeightMap, |
| typename Buffer> |
| void |
| brandes_betweenness_centrality(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| Buffer sources, |
| typename property_traits<WeightMap>::value_type delta, |
| WeightMap weight_map |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| graph::parallel::detail::brandes_shortest_paths<WeightMap> shortest_paths(weight_map, delta); |
| |
| graph::parallel::detail::brandes_betweenness_centrality_impl(g, centrality, |
| edge_centrality_map, |
| incoming, distance, |
| dependency, path_count, |
| vertex_index, |
| shortest_paths, |
| sources); |
| } |
| |
| namespace graph { namespace parallel { namespace detail { |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename WeightMap, typename VertexIndexMap, typename Buffer> |
| void |
| brandes_betweenness_centrality_dispatch2(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| WeightMap weight_map, |
| VertexIndexMap vertex_index, |
| Buffer sources, |
| typename property_traits<WeightMap>::value_type delta) |
| { |
| typedef typename graph_traits<Graph>::degree_size_type degree_size_type; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename mpl::if_c<(is_same<CentralityMap, |
| dummy_property_map>::value), |
| EdgeCentralityMap, |
| CentralityMap>::type a_centrality_map; |
| typedef typename property_traits<a_centrality_map>::value_type |
| centrality_type; |
| |
| typename graph_traits<Graph>::vertices_size_type V = num_vertices(g); |
| |
| std::vector<std::vector<vertex_descriptor> > incoming(V); |
| std::vector<centrality_type> distance(V); |
| std::vector<centrality_type> dependency(V); |
| std::vector<degree_size_type> path_count(V); |
| |
| brandes_betweenness_centrality( |
| g, centrality, edge_centrality_map, |
| make_iterator_property_map(incoming.begin(), vertex_index), |
| make_iterator_property_map(distance.begin(), vertex_index), |
| make_iterator_property_map(dependency.begin(), vertex_index), |
| make_iterator_property_map(path_count.begin(), vertex_index), |
| vertex_index, unwrap_ref(sources), delta, |
| weight_map); |
| } |
| |
| // TODO: Should the type of the distance and dependency map depend on the |
| // value type of the centrality map? |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename VertexIndexMap, typename Buffer> |
| void |
| brandes_betweenness_centrality_dispatch2(const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| VertexIndexMap vertex_index, |
| Buffer sources, |
| typename graph_traits<Graph>::edges_size_type delta) |
| { |
| typedef typename graph_traits<Graph>::degree_size_type degree_size_type; |
| typedef typename graph_traits<Graph>::edges_size_type edges_size_type; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename mpl::if_c<(is_same<CentralityMap, |
| dummy_property_map>::value), |
| EdgeCentralityMap, |
| CentralityMap>::type a_centrality_map; |
| |
| typename graph_traits<Graph>::vertices_size_type V = num_vertices(g); |
| |
| std::vector<std::vector<vertex_descriptor> > incoming(V); |
| std::vector<edges_size_type> distance(V); |
| std::vector<edges_size_type> dependency(V); |
| std::vector<degree_size_type> path_count(V); |
| |
| brandes_betweenness_centrality( |
| g, centrality, edge_centrality_map, |
| make_iterator_property_map(incoming.begin(), vertex_index), |
| make_iterator_property_map(distance.begin(), vertex_index), |
| make_iterator_property_map(dependency.begin(), vertex_index), |
| make_iterator_property_map(path_count.begin(), vertex_index), |
| vertex_index, unwrap_ref(sources), delta); |
| } |
| |
| template<typename WeightMap> |
| struct brandes_betweenness_centrality_dispatch1 |
| { |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename VertexIndexMap, typename Buffer> |
| static void |
| run(const Graph& g, CentralityMap centrality, EdgeCentralityMap edge_centrality_map, |
| VertexIndexMap vertex_index, Buffer sources, |
| typename property_traits<WeightMap>::value_type delta, WeightMap weight_map) |
| { |
| boost::graph::parallel::detail::brandes_betweenness_centrality_dispatch2( |
| g, centrality, edge_centrality_map, weight_map, vertex_index, sources, delta); |
| } |
| }; |
| |
| template<> |
| struct brandes_betweenness_centrality_dispatch1<boost::detail::error_property_not_found> |
| { |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap, |
| typename VertexIndexMap, typename Buffer> |
| static void |
| run(const Graph& g, CentralityMap centrality, EdgeCentralityMap edge_centrality_map, |
| VertexIndexMap vertex_index, Buffer sources, |
| typename graph_traits<Graph>::edges_size_type delta, |
| boost::detail::error_property_not_found) |
| { |
| boost::graph::parallel::detail::brandes_betweenness_centrality_dispatch2( |
| g, centrality, edge_centrality_map, vertex_index, sources, delta); |
| } |
| }; |
| |
| } } } // end namespace graph::parallel::detail |
| |
| template<typename Graph, typename Param, typename Tag, typename Rest> |
| void |
| brandes_betweenness_centrality(const Graph& g, |
| const bgl_named_params<Param,Tag,Rest>& params |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| typedef bgl_named_params<Param,Tag,Rest> named_params; |
| |
| typedef queue<typename graph_traits<Graph>::vertex_descriptor> queue_t; |
| queue_t q; |
| |
| typedef typename property_value<named_params, edge_weight_t>::type ew; |
| graph::parallel::detail::brandes_betweenness_centrality_dispatch1<ew>::run( |
| g, |
| choose_param(get_param(params, vertex_centrality), |
| dummy_property_map()), |
| choose_param(get_param(params, edge_centrality), |
| dummy_property_map()), |
| choose_const_pmap(get_param(params, vertex_index), g, vertex_index), |
| choose_param(get_param(params, buffer_param_t()), boost::ref(q)), |
| choose_param(get_param(params, lookahead_t()), 0), |
| get_param(params, edge_weight)); |
| } |
| |
| template<typename Graph, typename CentralityMap> |
| void |
| brandes_betweenness_centrality(const Graph& g, CentralityMap centrality |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| typedef queue<typename graph_traits<Graph>::vertex_descriptor> queue_t; |
| queue_t q; |
| |
| boost::graph::parallel::detail::brandes_betweenness_centrality_dispatch2( |
| g, centrality, dummy_property_map(), get(vertex_index, g), boost::ref(q), 0); |
| } |
| |
| template<typename Graph, typename CentralityMap, typename EdgeCentralityMap> |
| void |
| brandes_betweenness_centrality(const Graph& g, CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| typedef queue<int> queue_t; |
| queue_t q; |
| |
| boost::graph::parallel::detail::brandes_betweenness_centrality_dispatch2( |
| g, centrality, edge_centrality_map, get(vertex_index, g), boost::ref(q), 0); |
| } |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename IncomingMap, typename DistanceMap, |
| typename DependencyMap, typename PathCountMap, typename VertexIndexMap, |
| typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, |
| const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| Buffer sources) |
| { |
| typedef typename property_traits<DistanceMap>::value_type distance_type; |
| typedef static_property_map<distance_type> WeightMap; |
| |
| detail::graph::brandes_unweighted_shortest_paths shortest_paths; |
| |
| graph::parallel::detail::non_distributed_brandes_betweenness_centrality_impl(pg, g, centrality, |
| edge_centrality_map, |
| incoming, distance, |
| dependency, path_count, |
| vertex_index, |
| shortest_paths, |
| sources); |
| } |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename IncomingMap, typename DistanceMap, |
| typename DependencyMap, typename PathCountMap, typename VertexIndexMap, |
| typename WeightMap, typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, |
| const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| IncomingMap incoming, |
| DistanceMap distance, |
| DependencyMap dependency, |
| PathCountMap path_count, |
| VertexIndexMap vertex_index, |
| WeightMap weight_map, |
| Buffer sources) |
| { |
| detail::graph::brandes_dijkstra_shortest_paths<WeightMap> shortest_paths(weight_map); |
| |
| graph::parallel::detail::non_distributed_brandes_betweenness_centrality_impl(pg, g, centrality, |
| edge_centrality_map, |
| incoming, distance, |
| dependency, path_count, |
| vertex_index, |
| shortest_paths, |
| sources); |
| } |
| |
| namespace detail { namespace graph { |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename WeightMap, typename VertexIndexMap, |
| typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality_dispatch2(const ProcessGroup& pg, |
| const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| WeightMap weight_map, |
| VertexIndexMap vertex_index, |
| Buffer sources) |
| { |
| typedef typename graph_traits<Graph>::degree_size_type degree_size_type; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor; |
| typedef typename mpl::if_c<(is_same<CentralityMap, |
| dummy_property_map>::value), |
| EdgeCentralityMap, |
| CentralityMap>::type a_centrality_map; |
| typedef typename property_traits<a_centrality_map>::value_type |
| centrality_type; |
| |
| typename graph_traits<Graph>::vertices_size_type V = num_vertices(g); |
| |
| std::vector<std::vector<edge_descriptor> > incoming(V); |
| std::vector<centrality_type> distance(V); |
| std::vector<centrality_type> dependency(V); |
| std::vector<degree_size_type> path_count(V); |
| |
| non_distributed_brandes_betweenness_centrality( |
| pg, g, centrality, edge_centrality_map, |
| make_iterator_property_map(incoming.begin(), vertex_index), |
| make_iterator_property_map(distance.begin(), vertex_index), |
| make_iterator_property_map(dependency.begin(), vertex_index), |
| make_iterator_property_map(path_count.begin(), vertex_index), |
| vertex_index, weight_map, unwrap_ref(sources)); |
| } |
| |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename VertexIndexMap, typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality_dispatch2(const ProcessGroup& pg, |
| const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| VertexIndexMap vertex_index, |
| Buffer sources) |
| { |
| typedef typename graph_traits<Graph>::degree_size_type degree_size_type; |
| typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor; |
| typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor; |
| typedef typename mpl::if_c<(is_same<CentralityMap, |
| dummy_property_map>::value), |
| EdgeCentralityMap, |
| CentralityMap>::type a_centrality_map; |
| typedef typename property_traits<a_centrality_map>::value_type |
| centrality_type; |
| |
| typename graph_traits<Graph>::vertices_size_type V = num_vertices(g); |
| |
| std::vector<std::vector<edge_descriptor> > incoming(V); |
| std::vector<centrality_type> distance(V); |
| std::vector<centrality_type> dependency(V); |
| std::vector<degree_size_type> path_count(V); |
| |
| non_distributed_brandes_betweenness_centrality( |
| pg, g, centrality, edge_centrality_map, |
| make_iterator_property_map(incoming.begin(), vertex_index), |
| make_iterator_property_map(distance.begin(), vertex_index), |
| make_iterator_property_map(dependency.begin(), vertex_index), |
| make_iterator_property_map(path_count.begin(), vertex_index), |
| vertex_index, unwrap_ref(sources)); |
| } |
| |
| template<typename WeightMap> |
| struct non_distributed_brandes_betweenness_centrality_dispatch1 |
| { |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename VertexIndexMap, typename Buffer> |
| static void |
| run(const ProcessGroup& pg, const Graph& g, CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index, |
| Buffer sources, WeightMap weight_map) |
| { |
| non_distributed_brandes_betweenness_centrality_dispatch2(pg, g, centrality, edge_centrality_map, |
| weight_map, vertex_index, sources); |
| } |
| }; |
| |
| template<> |
| struct non_distributed_brandes_betweenness_centrality_dispatch1<detail::error_property_not_found> |
| { |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename VertexIndexMap, typename Buffer> |
| static void |
| run(const ProcessGroup& pg, const Graph& g, CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index, |
| Buffer sources, detail::error_property_not_found) |
| { |
| non_distributed_brandes_betweenness_centrality_dispatch2(pg, g, centrality, edge_centrality_map, |
| vertex_index, sources); |
| } |
| }; |
| |
| } } // end namespace detail::graph |
| |
| template<typename ProcessGroup, typename Graph, typename Param, typename Tag, typename Rest> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, const Graph& g, |
| const bgl_named_params<Param,Tag,Rest>& params) |
| { |
| typedef bgl_named_params<Param,Tag,Rest> named_params; |
| |
| typedef queue<int> queue_t; |
| queue_t q; |
| |
| typedef typename property_value<named_params, edge_weight_t>::type ew; |
| detail::graph::non_distributed_brandes_betweenness_centrality_dispatch1<ew>::run( |
| pg, g, |
| choose_param(get_param(params, vertex_centrality), |
| dummy_property_map()), |
| choose_param(get_param(params, edge_centrality), |
| dummy_property_map()), |
| choose_const_pmap(get_param(params, vertex_index), g, vertex_index), |
| choose_param(get_param(params, buffer_param_t()), boost::ref(q)), |
| get_param(params, edge_weight)); |
| } |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, const Graph& g, |
| CentralityMap centrality) |
| { |
| typedef queue<int> queue_t; |
| queue_t q; |
| |
| detail::graph::non_distributed_brandes_betweenness_centrality_dispatch2( |
| pg, g, centrality, dummy_property_map(), get(vertex_index, g), boost::ref(q)); |
| } |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, const Graph& g, |
| CentralityMap centrality, Buffer sources) |
| { |
| detail::graph::non_distributed_brandes_betweenness_centrality_dispatch2( |
| pg, g, centrality, dummy_property_map(), get(vertex_index, g), sources); |
| } |
| |
| template<typename ProcessGroup, typename Graph, typename CentralityMap, |
| typename EdgeCentralityMap, typename Buffer> |
| void |
| non_distributed_brandes_betweenness_centrality(const ProcessGroup& pg, const Graph& g, |
| CentralityMap centrality, |
| EdgeCentralityMap edge_centrality_map, |
| Buffer sources) |
| { |
| detail::graph::non_distributed_brandes_betweenness_centrality_dispatch2( |
| pg, g, centrality, edge_centrality_map, get(vertex_index, g), sources); |
| } |
| |
| // Compute the central point dominance of a graph. |
| // TODO: Make sure central point dominance works in parallel case |
| template<typename Graph, typename CentralityMap> |
| typename property_traits<CentralityMap>::value_type |
| central_point_dominance(const Graph& g, CentralityMap centrality |
| BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,distributed_graph_tag)) |
| { |
| using std::max; |
| |
| typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator; |
| typedef typename property_traits<CentralityMap>::value_type centrality_type; |
| typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type; |
| |
| typedef typename boost::graph::parallel::process_group_type<Graph>::type |
| process_group_type; |
| process_group_type pg = boost::graph::parallel::process_group(g); |
| |
| vertices_size_type n = num_vertices(g); |
| |
| using boost::parallel::all_reduce; |
| n = all_reduce(pg, n, std::plus<vertices_size_type>()); |
| |
| // Find max centrality |
| centrality_type max_centrality(0); |
| vertex_iterator v, v_end; |
| for (tie(v, v_end) = vertices(g); v != v_end; ++v) { |
| max_centrality = (max)(max_centrality, get(centrality, *v)); |
| } |
| |
| // All reduce to get global max centrality |
| max_centrality = all_reduce(pg, max_centrality, boost::parallel::maximum<centrality_type>()); |
| |
| // Compute central point dominance |
| centrality_type sum(0); |
| for (tie(v, v_end) = vertices(g); v != v_end; ++v) { |
| sum += (max_centrality - get(centrality, *v)); |
| } |
| |
| sum = all_reduce(pg, sum, std::plus<centrality_type>()); |
| |
| return sum/(n-1); |
| } |
| |
| } // end namespace boost |
| |
| #endif // BOOST_GRAPH_PARALLEL_BRANDES_BETWEENNESS_CENTRALITY_HPP |
