1701 lines
68 KiB
C++
1701 lines
68 KiB
C++
// 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>
|
|
#include <boost/assert.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 & boost::tuples::get<0>(t);
|
|
ar & boost::tuples::get<1>(t);
|
|
ar & boost::tuples::get<2>(t);
|
|
ar & boost::tuples::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 get(owner, boost::tuples::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::parallel::synchronize;
|
|
synchronize(pg);
|
|
}
|
|
|
|
// Setup triggers for msg_relax messages
|
|
void setup_triggers()
|
|
{
|
|
using boost::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,
|
|
boost::parallel::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), boost::parallel::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
|
|
)
|
|
{
|
|
// 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>::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 = boost::tuples::get<0>(x);
|
|
vertex_descriptor source = boost::tuples::get<1>(x);
|
|
dependency_type dep = boost::tuples::get<2>(x);
|
|
path_count_type pc = boost::tuples::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;
|
|
|
|
BOOST_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_descriptor vertex_descriptor;
|
|
|
|
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_descriptor vertex_descriptor;
|
|
|
|
// 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_descriptor vertex_descriptor;
|
|
|
|
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;
|
|
|
|
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::param_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::param_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 get_param_type<edge_weight_t, named_params>::type ew_param;
|
|
typedef typename detail::choose_impl_result<mpl::true_, Graph, ew_param, 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),
|
|
choose_const_pmap(get_param(params, edge_weight), g, 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)
|
|
{
|
|
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>::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>::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<param_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, param_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 get_param_type<edge_weight_t, named_params>::type ew_param;
|
|
typedef typename detail::choose_impl_result<mpl::true_, Graph, ew_param, 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)),
|
|
choose_const_pmap(get_param(params, edge_weight), g, 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 (boost::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 (boost::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
|