anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity
OpenGL Mathematics (GLM)
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
1096 Commits
1 Branch
0 Tags
73 MiB
 
 
 
Tag: Branch: Tree: c3b722a733
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from "c3b722a733"
${ noResults }
glm/test/external/boost/graph/distributed/adjacency_list.hpp

3970 lines
146 KiB
Raw Blame History

// Copyright (C) 2004-2006 The Trustees of Indiana University.
// Copyright (C) 2007 Douglas Gregor
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// Authors: Douglas Gregor
// Andrew Lumsdaine
#ifndef BOOST_GRAPH_DISTRIBUTED_ADJACENCY_LIST_HPP
#define BOOST_GRAPH_DISTRIBUTED_ADJACENCY_LIST_HPP
#ifndef BOOST_GRAPH_USE_MPI
#error "Parallel BGL files should not be included unless <boost/graph/use_mpi.hpp> has been included"
#endif
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/properties.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/iteration_macros.hpp>
#include <boost/graph/distributed/concepts.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/graph/adjacency_iterator.hpp>
#include <boost/property_map/parallel/distributed_property_map.hpp>
#include <boost/property_map/parallel/local_property_map.hpp>
#include <boost/graph/parallel/detail/property_holders.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/assert.hpp>
#include <list>
#include <algorithm>
#include <boost/limits.hpp>
#include <boost/graph/parallel/properties.hpp>
#include <boost/graph/parallel/distribution.hpp>
#include <boost/graph/parallel/algorithm.hpp>
#include <boost/graph/distributed/selector.hpp>
#include <boost/graph/parallel/process_group.hpp>
// Callbacks
#include <boost/function/function2.hpp>
// Serialization
#include <boost/serialization/base_object.hpp>
#include <boost/mpi/datatype.hpp>
#include <boost/pending/property_serialize.hpp>
#include <boost/graph/distributed/unsafe_serialize.hpp>
// Named vertices
#include <boost/graph/distributed/named_graph.hpp>
#include <boost/graph/distributed/shuffled_distribution.hpp>
namespace boost {
/// The type used to store an identifier that uniquely names a processor.
// NGE: I doubt we'll be running on more than 32768 procs for the time being
typedef /*int*/ short processor_id_type;
// Tell which processor the target of an edge resides on (for
// directed graphs) or which processor the other end point of the
// edge resides on (for undirected graphs).
enum edge_target_processor_id_t { edge_target_processor_id };
BOOST_INSTALL_PROPERTY(edge, target_processor_id);
// For undirected graphs, tells whether the edge is locally owned.
enum edge_locally_owned_t { edge_locally_owned };
BOOST_INSTALL_PROPERTY(edge, locally_owned);
// For bidirectional graphs, stores the incoming edges.
enum vertex_in_edges_t { vertex_in_edges };
BOOST_INSTALL_PROPERTY(vertex, in_edges);
/// Tag class for directed, distributed adjacency list
struct directed_distributed_adj_list_tag
: public virtual distributed_graph_tag,
public virtual distributed_vertex_list_graph_tag,
public virtual distributed_edge_list_graph_tag,
public virtual incidence_graph_tag,
public virtual adjacency_graph_tag {};
/// Tag class for bidirectional, distributed adjacency list
struct bidirectional_distributed_adj_list_tag
: public virtual distributed_graph_tag,
public virtual distributed_vertex_list_graph_tag,
public virtual distributed_edge_list_graph_tag,
public virtual incidence_graph_tag,
public virtual adjacency_graph_tag,
public virtual bidirectional_graph_tag {};
/// Tag class for undirected, distributed adjacency list
struct undirected_distributed_adj_list_tag
: public virtual distributed_graph_tag,
public virtual distributed_vertex_list_graph_tag,
public virtual distributed_edge_list_graph_tag,
public virtual incidence_graph_tag,
public virtual adjacency_graph_tag,
public virtual bidirectional_graph_tag {};
namespace detail {
template<typename Archiver, typename Directed, typename Vertex>
void
serialize(Archiver& ar, edge_base<Directed, Vertex>& e,
const unsigned int /*version*/)
{
ar & unsafe_serialize(e.m_source)
& unsafe_serialize(e.m_target);
}
template<typename Archiver, typename Directed, typename Vertex>
void
serialize(Archiver& ar, edge_desc_impl<Directed, Vertex>& e,
const unsigned int /*version*/)
{
ar & boost::serialization::base_object<edge_base<Directed, Vertex> >(e)
& unsafe_serialize(e.m_eproperty);
}
}
namespace detail { namespace parallel {
/**
* A distributed vertex descriptor. These descriptors contain both
* the ID of the processor that owns the vertex and a local vertex
* descriptor that identifies the particular vertex for that
* processor.
*/
template<typename LocalDescriptor>
struct global_descriptor
{
typedef LocalDescriptor local_descriptor_type;
global_descriptor() : owner(), local() { }
global_descriptor(processor_id_type owner, LocalDescriptor local)
: owner(owner), local(local) { }
processor_id_type owner;
LocalDescriptor local;
/**
* A function object that, given a processor ID, generates
* distributed vertex descriptors from local vertex
* descriptors. This function object is used by the
* vertex_iterator of the distributed adjacency list.
*/
struct generator
{
typedef global_descriptor<LocalDescriptor> result_type;
typedef LocalDescriptor argument_type;
generator() {}
generator(processor_id_type owner) : owner(owner) {}
result_type operator()(argument_type v) const
{ return result_type(owner, v); }
private:
processor_id_type owner;
};
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar & owner & unsafe_serialize(local);
}
};
/// Determine the process that owns the given descriptor
template<typename LocalDescriptor>
inline processor_id_type owner(const global_descriptor<LocalDescriptor>& v)
{ return v.owner; }
/// Determine the local portion of the given descriptor
template<typename LocalDescriptor>
inline LocalDescriptor local(const global_descriptor<LocalDescriptor>& v)
{ return v.local; }
/// Compare distributed vertex descriptors for equality
template<typename LocalDescriptor>
inline bool
operator==(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{
return u.owner == v.owner && u.local == v.local;
}
/// Compare distributed vertex descriptors for inequality
template<typename LocalDescriptor>
inline bool
operator!=(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{ return !(u == v); }
template<typename LocalDescriptor>
inline bool
operator<(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{
return (u.owner) < v.owner || (u.owner == v.owner && (u.local) < v.local);
}
template<typename LocalDescriptor>
inline bool
operator<=(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{
return u.owner <= v.owner || (u.owner == v.owner && u.local <= v.local);
}
template<typename LocalDescriptor>
inline bool
operator>(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{
return v < u;
}
template<typename LocalDescriptor>
inline bool
operator>=(const global_descriptor<LocalDescriptor>& u,
const global_descriptor<LocalDescriptor>& v)
{
return v <= u;
}
// DPG TBD: Add <, <=, >=, > for global descriptors
/**
* A Readable Property Map that extracts a global descriptor pair
* from a global_descriptor.
*/
template<typename LocalDescriptor>
struct global_descriptor_property_map
{
typedef std::pair<processor_id_type, LocalDescriptor> value_type;
typedef value_type reference;
typedef global_descriptor<LocalDescriptor> key_type;
typedef readable_property_map_tag category;
};
template<typename LocalDescriptor>
inline std::pair<processor_id_type, LocalDescriptor>
get(global_descriptor_property_map<LocalDescriptor>,
global_descriptor<LocalDescriptor> x)
{
return std::pair<processor_id_type, LocalDescriptor>(x.owner, x.local);
}
/**
* A Readable Property Map that extracts the owner of a global
* descriptor.
*/
template<typename LocalDescriptor>
struct owner_property_map
{
typedef processor_id_type value_type;
typedef value_type reference;
typedef global_descriptor<LocalDescriptor> key_type;
typedef readable_property_map_tag category;
};
template<typename LocalDescriptor>
inline processor_id_type
get(owner_property_map<LocalDescriptor>,
global_descriptor<LocalDescriptor> x)
{
return x.owner;
}
/**
* A Readable Property Map that extracts the local descriptor from
* a global descriptor.
*/
template<typename LocalDescriptor>
struct local_descriptor_property_map
{
typedef LocalDescriptor value_type;
typedef value_type reference;
typedef global_descriptor<LocalDescriptor> key_type;
typedef readable_property_map_tag category;
};
template<typename LocalDescriptor>
inline LocalDescriptor
get(local_descriptor_property_map<LocalDescriptor>,
global_descriptor<LocalDescriptor> x)
{
return x.local;
}
/**
* Stores an incoming edge for a bidirectional distributed
* adjacency list. The user does not see this type directly,
* because it is just an implementation detail.
*/
template<typename Edge>
struct stored_in_edge
{
stored_in_edge(processor_id_type sp, Edge e)
: source_processor(sp), e(e) {}
processor_id_type source_processor;
Edge e;
};
/**
* A distributed edge descriptor. These descriptors contain the
* underlying edge descriptor, the processor IDs for both the
* source and the target of the edge, and a boolean flag that
* indicates which of the processors actually owns the edge.
*/
template<typename Edge>
struct edge_descriptor
{
edge_descriptor(processor_id_type sp = processor_id_type(),
processor_id_type tp = processor_id_type(),
bool owns = false, Edge ld = Edge())
: source_processor(sp), target_processor(tp),
source_owns_edge(owns), local(ld) {}
processor_id_type owner() const
{
return source_owns_edge? source_processor : target_processor;
}
/// The processor that the source vertex resides on
processor_id_type source_processor;
/// The processor that the target vertex resides on
processor_id_type target_processor;
/// True when the source processor owns the edge, false when the
/// target processor owns the edge.
bool source_owns_edge;
/// The local edge descriptor.
Edge local;
/**
* Function object that generates edge descriptors for the
* out_edge_iterator of the given distributed adjacency list
* from the edge descriptors of the underlying adjacency list.
*/
template<typename Graph>
class out_generator
{
typedef typename Graph::directed_selector directed_selector;
public:
typedef edge_descriptor<Edge> result_type;
typedef Edge argument_type;
out_generator() : g(0) {}
explicit out_generator(const Graph& g) : g(&g) {}
result_type operator()(argument_type e) const
{ return map(e, directed_selector()); }
private:
result_type map(argument_type e, directedS) const
{
return result_type(g->processor(),
get(edge_target_processor_id, g->base(), e),
true, e);
}
result_type map(argument_type e, bidirectionalS) const
{
return result_type(g->processor(),
get(edge_target_processor_id, g->base(), e),
true, e);
}
result_type map(argument_type e, undirectedS) const
{
return result_type(g->processor(),
get(edge_target_processor_id, g->base(), e),
get(edge_locally_owned, g->base(), e),
e);
}
const Graph* g;
};
/**
* Function object that generates edge descriptors for the
* in_edge_iterator of the given distributed adjacency list
* from the edge descriptors of the underlying adjacency list.
*/
template<typename Graph>
class in_generator
{
typedef typename Graph::directed_selector DirectedS;
public:
typedef typename boost::mpl::if_<is_same<DirectedS, bidirectionalS>,
stored_in_edge<Edge>,
Edge>::type argument_type;
typedef edge_descriptor<Edge> result_type;
in_generator() : g(0) {}
explicit in_generator(const Graph& g) : g(&g) {}
result_type operator()(argument_type e) const
{ return map(e, DirectedS()); }
private:
/**
* For a bidirectional graph, we just generate the appropriate
* edge. No tricks.
*/
result_type map(argument_type e, bidirectionalS) const
{
return result_type(e.source_processor,
g->processor(),
true,
e.e);
}
/**
* For an undirected graph, we generate descriptors for the
* incoming edges by swapping the source/target of the
* underlying edge descriptor (a hack). The target processor
* ID on the edge is actually the source processor for this
* edge, and our processor is the target processor. If the
* edge is locally owned, then it is owned by the target (us);
* otherwise it is owned by the source.
*/
result_type map(argument_type e, undirectedS) const
{
typename Graph::local_edge_descriptor local_edge(e);
// TBD: This is a very, VERY lame hack that takes advantage
// of our knowledge of the internals of the BGL
// adjacency_list. There should be a cleaner way to handle
// this...
using std::swap;
swap(local_edge.m_source, local_edge.m_target);
return result_type(get(edge_target_processor_id, g->base(), e),
g->processor(),
!get(edge_locally_owned, g->base(), e),
local_edge);
}
const Graph* g;
};
private:
friend class boost::serialization::access;
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar
& source_processor
& target_processor
& source_owns_edge
& local;
}
};
/// Determine the process that owns this edge
template<typename Edge>
inline processor_id_type
owner(const edge_descriptor<Edge>& e)
{ return e.source_owns_edge? e.source_processor : e.target_processor; }
/// Determine the local descriptor for this edge.
template<typename Edge>
inline Edge
local(const edge_descriptor<Edge>& e)
{ return e.local; }
/**
* A Readable Property Map that extracts the owner and local
* descriptor of an edge descriptor.
*/
template<typename Edge>
struct edge_global_property_map
{
typedef std::pair<processor_id_type, Edge> value_type;
typedef value_type reference;
typedef edge_descriptor<Edge> key_type;
typedef readable_property_map_tag category;
};
template<typename Edge>
inline std::pair<processor_id_type, Edge>
get(edge_global_property_map<Edge>, const edge_descriptor<Edge>& e)
{
typedef std::pair<processor_id_type, Edge> result_type;
return result_type(e.source_owns_edge? e.source_processor
/* target owns edge*/: e.target_processor,
e.local);
}
/**
* A Readable Property Map that extracts the owner of an edge
* descriptor.
*/
template<typename Edge>
struct edge_owner_property_map
{
typedef processor_id_type value_type;
typedef value_type reference;
typedef edge_descriptor<Edge> key_type;
typedef readable_property_map_tag category;
};
template<typename Edge>
inline processor_id_type
get(edge_owner_property_map<Edge>, const edge_descriptor<Edge>& e)
{
return e.source_owns_edge? e.source_processor : e.target_processor;
}
/**
* A Readable Property Map that extracts the local descriptor from
* an edge descriptor.
*/
template<typename Edge>
struct edge_local_property_map
{
typedef Edge value_type;
typedef value_type reference;
typedef edge_descriptor<Edge> key_type;
typedef readable_property_map_tag category;
};
template<typename Edge>
inline Edge
get(edge_local_property_map<Edge>,
const edge_descriptor<Edge>& e)
{
return e.local;
}
/** Compare distributed edge descriptors for equality.
*
* \todo need edge_descriptor to know if it is undirected so we
* can compare both ways.
*/
template<typename Edge>
inline bool
operator==(const edge_descriptor<Edge>& e1,
const edge_descriptor<Edge>& e2)
{
return (e1.source_processor == e2.source_processor
&& e1.target_processor == e2.target_processor
&& e1.local == e2.local);
}
/// Compare distributed edge descriptors for inequality.
template<typename Edge>
inline bool
operator!=(const edge_descriptor<Edge>& e1,
const edge_descriptor<Edge>& e2)
{ return !(e1 == e2); }
/**
* Configuration for the distributed adjacency list. We use this
* parameter to store all of the configuration details for the
* implementation of the distributed adjacency list, which allows us to
* get at the distribution type in the maybe_named_graph.
*/
template<typename OutEdgeListS, typename ProcessGroup,
typename InVertexListS, typename InDistribution,
typename DirectedS, typename VertexProperty,
typename EdgeProperty, typename GraphProperty,
typename EdgeListS>
struct adjacency_list_config
{
typedef typename mpl::if_<is_same<InVertexListS, defaultS>,
vecS, InVertexListS>::type
VertexListS;
/// Introduce the target processor ID property for each edge
typedef property<edge_target_processor_id_t, processor_id_type,
EdgeProperty> edge_property_with_id;
/// For undirected graphs, introduce the locally-owned property for edges
typedef typename boost::mpl::if_<is_same<DirectedS, undirectedS>,
property<edge_locally_owned_t, bool,
edge_property_with_id>,
edge_property_with_id>::type
base_edge_property_type;
/// The edge descriptor type for the local subgraph
typedef typename adjacency_list_traits<OutEdgeListS,
VertexListS,
directedS>::edge_descriptor
local_edge_descriptor;
/// For bidirectional graphs, the type of an incoming stored edge
typedef stored_in_edge<local_edge_descriptor> bidir_stored_edge;
/// The container type that will store incoming edges for a
/// bidirectional graph.
typedef typename container_gen<EdgeListS, bidir_stored_edge>::type
in_edge_list_type;
// Bidirectional graphs have an extra vertex property to store
// the incoming edges.
typedef typename boost::mpl::if_<is_same<DirectedS, bidirectionalS>,
property<vertex_in_edges_t, in_edge_list_type,
VertexProperty>,
VertexProperty>::type
base_vertex_property_type;
// The type of the distributed adjacency list
typedef adjacency_list<OutEdgeListS,
distributedS<ProcessGroup,
VertexListS,
InDistribution>,
DirectedS, VertexProperty, EdgeProperty,
GraphProperty, EdgeListS>
graph_type;
// The type of the underlying adjacency list implementation
typedef adjacency_list<OutEdgeListS, VertexListS, directedS,
base_vertex_property_type,
base_edge_property_type,
GraphProperty,
EdgeListS>
inherited;
typedef InDistribution in_distribution_type;
typedef typename inherited::vertices_size_type vertices_size_type;
typedef typename ::boost::graph::distributed::select_distribution<
in_distribution_type, VertexProperty, vertices_size_type,
ProcessGroup>::type
base_distribution_type;
typedef ::boost::graph::distributed::shuffled_distribution<
base_distribution_type> distribution_type;
typedef VertexProperty vertex_property_type;
typedef EdgeProperty edge_property_type;
typedef ProcessGroup process_group_type;
typedef VertexListS vertex_list_selector;
typedef OutEdgeListS out_edge_list_selector;
typedef DirectedS directed_selector;
typedef GraphProperty graph_property_type;
typedef EdgeListS edge_list_selector;
};
// Maybe initialize the indices of each vertex
template<typename IteratorPair, typename VertexIndexMap>
void
maybe_initialize_vertex_indices(IteratorPair p, VertexIndexMap to_index,
read_write_property_map_tag)
{
typedef typename property_traits<VertexIndexMap>::value_type index_t;
index_t next_index = 0;
while (p.first != p.second)
put(to_index, *p.first++, next_index++);
}
template<typename IteratorPair, typename VertexIndexMap>
inline void
maybe_initialize_vertex_indices(IteratorPair p, VertexIndexMap to_index,
readable_property_map_tag)
{
// Do nothing
}
template<typename IteratorPair, typename VertexIndexMap>
inline void
maybe_initialize_vertex_indices(IteratorPair p, VertexIndexMap to_index)
{
typedef typename property_traits<VertexIndexMap>::category category;
maybe_initialize_vertex_indices(p, to_index, category());
}
template<typename IteratorPair>
inline void
maybe_initialize_vertex_indices(IteratorPair p,
::boost::detail::error_property_not_found)
{ }
/***********************************************************************
* Message Payloads *
***********************************************************************/
/**
* Data stored with a msg_add_edge message, which requests the
* remote addition of an edge.
*/
template<typename Vertex, typename LocalVertex>
struct msg_add_edge_data
{
msg_add_edge_data() { }
msg_add_edge_data(Vertex source, Vertex target)
: source(source.local), target(target) { }
/// The source of the edge; the processor will be the
/// receiving processor.
LocalVertex source;
/// The target of the edge.
Vertex target;
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar & unsafe_serialize(source) & target;
}
};
/**
* Like @c msg_add_edge_data, but also includes a user-specified
* property value to be attached to the edge.
*/
template<typename Vertex, typename LocalVertex, typename EdgeProperty>
struct msg_add_edge_with_property_data
: msg_add_edge_data<Vertex, LocalVertex>,
maybe_store_property<EdgeProperty>
{
private:
typedef msg_add_edge_data<Vertex, LocalVertex> inherited_data;
typedef maybe_store_property<EdgeProperty> inherited_property;
public:
msg_add_edge_with_property_data() { }
msg_add_edge_with_property_data(Vertex source,
Vertex target,
const EdgeProperty& property)
: inherited_data(source, target),
inherited_property(property) { }
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar & boost::serialization::base_object<inherited_data>(*this)
& boost::serialization::base_object<inherited_property>(*this);
}
};
//------------------------------------------------------------------------
// Distributed adjacency list property map details
/**
* Metafunction that extracts the given property from the given
* distributed adjacency list type. This could be implemented much
* more cleanly, but even newer versions of GCC (e.g., 3.2.3)
* cannot properly handle partial specializations involving
* enumerator types.
*/
template<typename Property>
struct get_adj_list_pmap
{
template<typename Graph>
struct apply
{
typedef Graph graph_type;
typedef typename graph_type::process_group_type process_group_type;
typedef typename graph_type::inherited base_graph_type;
typedef typename property_map<base_graph_type, Property>::type
local_pmap;
typedef typename property_map<base_graph_type, Property>::const_type
local_const_pmap;
typedef graph_traits<graph_type> traits;
typedef typename graph_type::local_vertex_descriptor local_vertex;
typedef typename property_traits<local_pmap>::key_type local_key_type;
typedef typename property_traits<local_pmap>::value_type value_type;
typedef typename property_map<Graph, vertex_global_t>::const_type
vertex_global_map;
typedef typename property_map<Graph, edge_global_t>::const_type
edge_global_map;
typedef typename mpl::if_c<(is_same<local_key_type,
local_vertex>::value),
vertex_global_map, edge_global_map>::type
global_map;
public:
typedef ::boost::parallel::distributed_property_map<
process_group_type, global_map, local_pmap> type;
typedef ::boost::parallel::distributed_property_map<
process_group_type, global_map, local_const_pmap> const_type;
};
};
/**
* The local vertex index property map is actually a mapping from
* the local vertex descriptors to vertex indices.
*/
template<>
struct get_adj_list_pmap<vertex_local_index_t>
{
template<typename Graph>
struct apply
: ::boost::property_map<typename Graph::inherited, vertex_index_t>
{ };
};
/**
* The vertex index property map maps from global descriptors
* (e.g., the vertex descriptor of a distributed adjacency list)
* to the underlying local index. It is not valid to use this
* property map with nonlocal descriptors.
*/
template<>
struct get_adj_list_pmap<vertex_index_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename property_map<Graph, vertex_global_t>::const_type
global_map;
typedef property_map<typename Graph::inherited, vertex_index_t> local;
public:
typedef local_property_map<typename Graph::process_group_type,
global_map,
typename local::type> type;
typedef local_property_map<typename Graph::process_group_type,
global_map,
typename local::const_type> const_type;
};
};
/**
* The vertex owner property map maps from vertex descriptors to
* the processor that owns the vertex.
*/
template<>
struct get_adj_list_pmap<vertex_global_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_vertex_descriptor
local_vertex_descriptor;
public:
typedef global_descriptor_property_map<local_vertex_descriptor> type;
typedef type const_type;
};
};
/**
* The vertex owner property map maps from vertex descriptors to
* the processor that owns the vertex.
*/
template<>
struct get_adj_list_pmap<vertex_owner_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_vertex_descriptor
local_vertex_descriptor;
public:
typedef owner_property_map<local_vertex_descriptor> type;
typedef type const_type;
};
};
/**
* The vertex local property map maps from vertex descriptors to
* the local descriptor for that vertex.
*/
template<>
struct get_adj_list_pmap<vertex_local_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_vertex_descriptor
local_vertex_descriptor;
public:
typedef local_descriptor_property_map<local_vertex_descriptor> type;
typedef type const_type;
};
};
/**
* The edge global property map maps from edge descriptors to
* a pair of the owning processor and local descriptor.
*/
template<>
struct get_adj_list_pmap<edge_global_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_edge_descriptor
local_edge_descriptor;
public:
typedef edge_global_property_map<local_edge_descriptor> type;
typedef type const_type;
};
};
/**
* The edge owner property map maps from edge descriptors to
* the processor that owns the edge.
*/
template<>
struct get_adj_list_pmap<edge_owner_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_edge_descriptor
local_edge_descriptor;
public:
typedef edge_owner_property_map<local_edge_descriptor> type;
typedef type const_type;
};
};
/**
* The edge local property map maps from edge descriptors to
* the local descriptor for that edge.
*/
template<>
struct get_adj_list_pmap<edge_local_t>
{
template<typename Graph>
struct apply
{
private:
typedef typename Graph::local_edge_descriptor
local_edge_descriptor;
public:
typedef edge_local_property_map<local_edge_descriptor> type;
typedef type const_type;
};
};
//------------------------------------------------------------------------
// Directed graphs do not have in edges, so this is a no-op
template<typename Graph>
inline void
remove_in_edge(typename Graph::edge_descriptor, Graph&, directedS)
{ }
// Bidirectional graphs have in edges stored in the
// vertex_in_edges property.
template<typename Graph>
inline void
remove_in_edge(typename Graph::edge_descriptor e, Graph& g, bidirectionalS)
{
typedef typename Graph::in_edge_list_type in_edge_list_type;
in_edge_list_type& in_edges =
get(vertex_in_edges, g.base())[target(e, g).local];
typename in_edge_list_type::iterator i = in_edges.begin();
while (i != in_edges.end()
&& !(i->source_processor == source(e, g).owner)
&& i->e == e.local)
++i;
BOOST_ASSERT(i != in_edges.end());
in_edges.erase(i);
}
// Undirected graphs have in edges stored as normal edges.
template<typename Graph>
inline void
remove_in_edge(typename Graph::edge_descriptor e, Graph& g, undirectedS)
{
typedef typename Graph::inherited base_type;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
// TBD: can we make this more efficient?
// Removing edge (v, u). v is local
base_type& bg = g.base();
vertex_descriptor u = source(e, g);
vertex_descriptor v = target(e, g);
if (v.owner != process_id(g.process_group())) {
using std::swap;
swap(u, v);
}
typename graph_traits<base_type>::out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(v.local, bg); ei != ei_end; ++ei)
{
if (target(*ei, g.base()) == u.local
// TBD: deal with parallel edges properly && *ei == e
&& get(edge_target_processor_id, bg, *ei) == u.owner) {
remove_edge(ei, bg);
return;
}
}
if (v.owner == process_id(g.process_group())) {
}
}
//------------------------------------------------------------------------
// Lazy addition of edges
// Work around the fact that an adjacency_list with vecS vertex
// storage automatically adds edges when the descriptor is
// out-of-range.
template <class Graph, class Config, class Base>
inline std::pair<typename Config::edge_descriptor, bool>
add_local_edge(typename Config::vertex_descriptor u,
typename Config::vertex_descriptor v,
const typename Config::edge_property_type& p,
vec_adj_list_impl<Graph, Config, Base>& g_)
{
adj_list_helper<Config, Base>& g = g_;
return add_edge(u, v, p, g);
}
template <class Graph, class Config, class Base>
inline std::pair<typename Config::edge_descriptor, bool>
add_local_edge(typename Config::vertex_descriptor u,
typename Config::vertex_descriptor v,
const typename Config::edge_property_type& p,
boost::adj_list_impl<Graph, Config, Base>& g)
{
return add_edge(u, v, p, g);
}
template <class EdgeProperty,class EdgeDescriptor>
struct msg_nonlocal_edge_data
: public detail::parallel::maybe_store_property<EdgeProperty>
{
typedef EdgeProperty edge_property_type;
typedef EdgeDescriptor local_edge_descriptor;
typedef detail::parallel::maybe_store_property<edge_property_type>
inherited;
msg_nonlocal_edge_data() {}
msg_nonlocal_edge_data(local_edge_descriptor e,
const edge_property_type& p)
: inherited(p), e(e) { }
local_edge_descriptor e;
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar & boost::serialization::base_object<inherited>(*this) & e;
}
};
template <class EdgeDescriptor>
struct msg_remove_edge_data
{
typedef EdgeDescriptor edge_descriptor;
msg_remove_edge_data() {}
explicit msg_remove_edge_data(edge_descriptor e) : e(e) {}
edge_descriptor e;
template<typename Archiver>
void serialize(Archiver& ar, const unsigned int /*version*/)
{
ar & e;
}
};
} } // end namespace detail::parallel
/**
* Adjacency list traits for a distributed adjacency list. Contains
* the vertex and edge descriptors, the directed-ness, and the
* parallel edges typedefs.
*/
template<typename OutEdgeListS, typename ProcessGroup,
typename InVertexListS, typename InDistribution, typename DirectedS>
struct adjacency_list_traits<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS>
{
private:
typedef typename mpl::if_<is_same<InVertexListS, defaultS>,
vecS,
InVertexListS>::type VertexListS;
typedef adjacency_list_traits<OutEdgeListS, VertexListS, directedS>
base_type;
public:
typedef typename base_type::vertex_descriptor local_vertex_descriptor;
typedef typename base_type::edge_descriptor local_edge_descriptor;
typedef typename boost::mpl::if_<typename DirectedS::is_bidir_t,
bidirectional_tag,
typename boost::mpl::if_<typename DirectedS::is_directed_t,
directed_tag, undirected_tag
>::type
>::type directed_category;
typedef typename parallel_edge_traits<OutEdgeListS>::type
edge_parallel_category;
typedef detail::parallel::global_descriptor<local_vertex_descriptor>
vertex_descriptor;
typedef detail::parallel::edge_descriptor<local_edge_descriptor>
edge_descriptor;
};
#define PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS \
typename OutEdgeListS, typename ProcessGroup, typename InVertexListS, \
typename InDistribution, typename DirectedS, typename VertexProperty, \
typename EdgeProperty, typename GraphProperty, typename EdgeListS
#define PBGL_DISTRIB_ADJLIST_TYPE \
adjacency_list<OutEdgeListS, \
distributedS<ProcessGroup, InVertexListS, InDistribution>, \
DirectedS, VertexProperty, EdgeProperty, GraphProperty, \
EdgeListS>
#define PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG \
typename OutEdgeListS, typename ProcessGroup, typename InVertexListS, \
typename InDistribution, typename VertexProperty, \
typename EdgeProperty, typename GraphProperty, typename EdgeListS
#define PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directed) \
adjacency_list<OutEdgeListS, \
distributedS<ProcessGroup, InVertexListS, InDistribution>, \
directed, VertexProperty, EdgeProperty, GraphProperty, \
EdgeListS>
/** A distributed adjacency list.
*
* This class template partial specialization defines a distributed
* (or "partitioned") adjacency list graph. The distributed
* adjacency list is similar to the standard Boost Graph Library
* adjacency list, which stores a list of vertices and for each
* verted the list of edges outgoing from the vertex (and, in some
* cases, also the edges incoming to the vertex). The distributed
* adjacency list differs in that it partitions the graph into
* several subgraphs that are then divided among different
* processors (or nodes within a cluster). The distributed adjacency
* list attempts to maintain a high degree of compatibility with the
* standard, non-distributed adjacency list.
*
* The graph is partitioned by vertex, with each processor storing
* all of the required information for a particular subset of the
* vertices, including vertex properties, outgoing edges, and (for
* bidirectional graphs) incoming edges. This information is
* accessible only on the processor that owns the vertex: for
* instance, if processor 0 owns vertex @c v, no other processor can
* directly access the properties of @c v or enumerate its outgoing
* edges.
*
* Edges in a graph may be entirely local (connecting two local
* vertices), but more often it is the case that edges are
* non-local, meaning that the two vertices they connect reside in
* different processes. Edge properties are stored with the
* originating vertex for directed and bidirectional graphs, and are
* therefore only accessible from the processor that owns the
* originating vertex. Other processors may query the source and
* target of the edge, but cannot access its properties. This is
* particularly interesting when accessing the incoming edges of a
* bidirectional graph, which are not guaranteed to be stored on the
* processor that is able to perform the iteration. For undirected
* graphs the situation is more complicated, since no vertex clearly
* owns the edges: the list of edges incident to a vertex may
* contain a mix of local and non-local edges.
*
* The distributed adjacency list is able to model several of the
* existing Graph concepts. It models the Graph concept because it
* exposes vertex and edge descriptors in the normal way; these
* descriptors model the GlobalDescriptor concept (because they have
* an owner and a local descriptor), and as such the distributed
* adjacency list models the DistributedGraph concept. The adjacency
* list also models the IncidenceGraph and AdjacencyGraph concepts,
* although this is only true so long as the domain of the valid
* expression arguments are restricted to vertices and edges stored
* locally. Likewise, bidirectional and undirected distributed
* adjacency lists model the BidirectionalGraph concept (vertex and
* edge domains must be respectived) and the distributed adjacency
* list models the MutableGraph concept (vertices and edges can only
* be added or removed locally). T he distributed adjacency list
* does not, however, model the VertexListGraph or EdgeListGraph
* concepts, because we can not efficiently enumerate all vertices
* or edges in the graph. Instead, the local subsets of vertices and
* edges can be enumerated (with the same syntax): the distributed
* adjacency list therefore models the DistributedVertexListGraph
* and DistributedEdgeListGraph concepts, because concurrent
* iteration over all of the vertices or edges stored on each
* processor will visit each vertex or edge.
*
* The distributed adjacency list is distinguished from the
* non-distributed version by the vertex list descriptor, which will
* be @c distributedS<ProcessGroup,VertexListS>. Here,
* the VertexListS type plays the same role as the VertexListS type
* in the non-distributed adjacency list: it allows one to select
* the data structure that will be used to store the local
* vertices. The ProcessGroup type, on the other hand, is unique to
* distributed data structures: it is the type that abstracts a
* group of cooperating processes, and it used for process
* identification, communication, and synchronization, among other
* things. Different process group types represent different
* communication mediums (e.g., MPI, PVM, TCP) or different models
* of communication (LogP, CGM, BSP, synchronous, etc.). This
* distributed adjacency list assumes a model based on non-blocking
* sends.
*
* Distribution of vertices across different processors is
* accomplished in two different ways. When initially constructing
* the graph, the user may provide a distribution object (that
* models the Distribution concept), which will determine the
* distribution of vertices to each process. Additionally, the @c
* add_vertex and @c add_edge operations add vertices or edges
* stored on the local processor. For @c add_edge, this is
* accomplished by requiring that the source vertex of the new edge
* be local to the process executing @c add_edge.
*
* Internal properties of a distributed adjacency list are
* accessible in the same manner as internal properties for a
* non-distributed adjacency list for local vertices or
* edges. Access to properties for remote vertices or edges occurs
* with the same syntax, but involve communication with the owner of
* the information: for more information, refer to class template
* @ref distributed_property_map, which manages distributed
* property maps. Note that the distributed property maps created
* for internal properties determine their reduction operation via
* the metafunction @ref property_reduce, which for the vast
* majority of uses is correct behavior.
*
* Communication among the processes coordinating on a particular
* distributed graph relies on non-blocking message passing along
* with synchronization. Local portions of the distributed graph may
* be modified concurrently, including the introduction of non-local
* edges, but prior to accessing the graph it is recommended that
* the @c synchronize free function be invoked on the graph to clear
* up any pending interprocess communication and modifications. All
* processes will then be released from the synchronization barrier
* concurrently.
*
* \todo Determine precisely what we should do with nonlocal edges
* in undirected graphs. Our parallelization of certain algorithms
* relies on the ability to access edge property maps immediately
* (e.g., edge_weight_t), so it may be necessary to duplicate the
* edge properties in both processes (but then we need some form of
* coherence protocol).
*
* \todo What does the user do if @c property_reduce doesn't do the
* right thing?
*/
template<typename OutEdgeListS, typename ProcessGroup,
typename InVertexListS, typename InDistribution, typename DirectedS,
typename VertexProperty, typename EdgeProperty,
typename GraphProperty, typename EdgeListS>
class adjacency_list<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty, EdgeListS>
: // Support for named vertices
public graph::distributed::maybe_named_graph<
adjacency_list<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty, EdgeListS>,
typename adjacency_list_traits<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS>::vertex_descriptor,
typename adjacency_list_traits<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS>::edge_descriptor,
detail::parallel::adjacency_list_config<OutEdgeListS, ProcessGroup,
InVertexListS, InDistribution,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty,
EdgeListS> >
{
typedef detail::parallel::adjacency_list_config<OutEdgeListS, ProcessGroup,
InVertexListS, InDistribution,
DirectedS, VertexProperty,
EdgeProperty, GraphProperty,
EdgeListS>
config_type;
typedef adjacency_list_traits<OutEdgeListS,
distributedS<ProcessGroup,
InVertexListS,
InDistribution>,
DirectedS>
traits_type;
typedef typename DirectedS::is_directed_t is_directed;
typedef EdgeListS edge_list_selector;
public:
/// The container type that will store incoming edges for a
/// bidirectional graph.
typedef typename config_type::in_edge_list_type in_edge_list_type;
// typedef typename inherited::edge_descriptor edge_descriptor;
/// The type of the underlying adjacency list implementation
typedef typename config_type::inherited inherited;
/// The type of properties stored in the local subgraph
/// Bidirectional graphs have an extra vertex property to store
/// the incoming edges.
typedef typename inherited::vertex_property_type
base_vertex_property_type;
/// The type of the distributed adjacency list (this type)
typedef typename config_type::graph_type graph_type;
/// Expose graph components and graph category
typedef typename traits_type::local_vertex_descriptor
local_vertex_descriptor;
typedef typename traits_type::local_edge_descriptor
local_edge_descriptor;
typedef typename traits_type::vertex_descriptor vertex_descriptor;
typedef typename traits_type::edge_descriptor edge_descriptor;
typedef typename traits_type::directed_category directed_category;
typedef typename inherited::edge_parallel_category
edge_parallel_category;
typedef typename inherited::graph_tag graph_tag;
// Current implementation requires the ability to have parallel
// edges in the underlying adjacency_list. Which processor each
// edge refers to is attached as an internal property. TBD:
// remove this restriction, which may require some rewriting.
BOOST_STATIC_ASSERT((is_same<edge_parallel_category,
allow_parallel_edge_tag>::value));
/** Determine the graph traversal category.
*
* A directed distributed adjacency list models the Distributed
* Graph, Incidence Graph, and Adjacency Graph
* concepts. Bidirectional and undirected graphs also model the
* Bidirectional Graph concept. Note that when modeling these
* concepts the domains of certain operations (e.g., in_edges)
* are restricted; see the distributed adjacency_list
* documentation.
*/
typedef typename boost::mpl::if_<
is_same<DirectedS, directedS>,
directed_distributed_adj_list_tag,
typename boost::mpl::if_<is_same<DirectedS, bidirectionalS>,
bidirectional_distributed_adj_list_tag,
undirected_distributed_adj_list_tag>::type>
::type traversal_category;
typedef typename inherited::degree_size_type degree_size_type;
typedef typename inherited::vertices_size_type vertices_size_type;
typedef typename inherited::edges_size_type edges_size_type;
typedef VertexProperty vertex_property_type;
typedef EdgeProperty edge_property_type;
typedef typename inherited::graph_property_type graph_property_type;
typedef typename inherited::vertex_bundled vertex_bundled;
typedef typename inherited::edge_bundled edge_bundled;
typedef typename inherited::graph_bundled graph_bundled;
typedef typename container_gen<edge_list_selector, edge_descriptor>::type
local_edge_list_type;
private:
typedef typename boost::mpl::if_<is_same<DirectedS, bidirectionalS>,
typename in_edge_list_type::const_iterator,
typename inherited::out_edge_iterator>::type
base_in_edge_iterator;
typedef typename inherited::out_edge_iterator base_out_edge_iterator;
typedef typename graph_traits<inherited>::edge_iterator
base_edge_iterator;
typedef typename inherited::edge_property_type base_edge_property_type;
typedef typename local_edge_list_type::const_iterator
undirected_edge_iterator;
typedef InDistribution in_distribution_type;
typedef parallel::trigger_receive_context trigger_receive_context;
public:
/// Iterator over the (local) vertices of the graph
typedef transform_iterator<typename vertex_descriptor::generator,
typename inherited::vertex_iterator>
vertex_iterator;
/// Helper for out_edge_iterator
typedef typename edge_descriptor::template out_generator<adjacency_list>
out_edge_generator;
/// Iterator over the outgoing edges of a vertex
typedef transform_iterator<out_edge_generator,
typename inherited::out_edge_iterator>
out_edge_iterator;
/// Helper for in_edge_iterator
typedef typename edge_descriptor::template in_generator<adjacency_list>
in_edge_generator;
/// Iterator over the incoming edges of a vertex
typedef transform_iterator<in_edge_generator, base_in_edge_iterator>
in_edge_iterator;
/// Iterator over the neighbors of a vertex
typedef boost::adjacency_iterator<
adjacency_list, vertex_descriptor, out_edge_iterator,
typename detail::iterator_traits<base_out_edge_iterator>
::difference_type>
adjacency_iterator;
/// Iterator over the (local) edges in a graph
typedef typename boost::mpl::if_<is_same<DirectedS, undirectedS>,
undirected_edge_iterator,
transform_iterator<out_edge_generator,
base_edge_iterator>
>::type
edge_iterator;
public:
/// The type of the mixin for named vertices
typedef graph::distributed::maybe_named_graph<graph_type,
vertex_descriptor,
edge_descriptor,
config_type>
named_graph_mixin;
/// Process group used for communication
typedef ProcessGroup process_group_type;
/// How to refer to a process
typedef typename process_group_type::process_id_type process_id_type;
/// Whether this graph is directed, undirected, or bidirectional
typedef DirectedS directed_selector;
// Structure used for the lazy addition of vertices
struct lazy_add_vertex_with_property;
friend struct lazy_add_vertex_with_property;
// Structure used for the lazy addition of edges
struct lazy_add_edge;
friend struct lazy_add_edge;
// Structure used for the lazy addition of edges with properties
struct lazy_add_edge_with_property;
friend struct lazy_add_edge_with_property;
/// default_distribution_type is the type of the distribution used if the
/// user didn't specify an explicit one
typedef typename graph::distributed::select_distribution<
InDistribution, VertexProperty, vertices_size_type,
ProcessGroup>::default_type
default_distribution_type;
/// distribution_type is the type of the distribution instance stored in
/// the maybe_named_graph base class
typedef typename graph::distributed::select_distribution<
InDistribution, VertexProperty, vertices_size_type,
ProcessGroup>::type
base_distribution_type;
typedef graph::distributed::shuffled_distribution<
base_distribution_type> distribution_type;
private:
// FIXME: the original adjacency_list contained this comment:
// Default copy constructor and copy assignment operators OK??? TBD
// but the adj_list_impl contained these declarations:
adjacency_list(const adjacency_list& other);
adjacency_list& operator=(const adjacency_list& other);
public:
adjacency_list(const ProcessGroup& pg = ProcessGroup())
: named_graph_mixin(pg, default_distribution_type(pg, 0)),
m_local_graph(GraphProperty()),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
}
adjacency_list(const ProcessGroup& pg,
const base_distribution_type& distribution)
: named_graph_mixin(pg, distribution),
m_local_graph(GraphProperty()),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
}
adjacency_list(const GraphProperty& g,
const ProcessGroup& pg = ProcessGroup())
: named_graph_mixin(pg, default_distribution_type(pg, 0)),
m_local_graph(g),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
}
adjacency_list(vertices_size_type n,
const GraphProperty& p,
const ProcessGroup& pg,
const base_distribution_type& distribution)
: named_graph_mixin(pg, distribution),
m_local_graph(distribution.block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
adjacency_list(vertices_size_type n,
const ProcessGroup& pg,
const base_distribution_type& distribution)
: named_graph_mixin(pg, distribution),
m_local_graph(distribution.block_size(process_id(pg), n), GraphProperty()),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
adjacency_list(vertices_size_type n,
const GraphProperty& p,
const ProcessGroup& pg = ProcessGroup())
: named_graph_mixin(pg, default_distribution_type(pg, n)),
m_local_graph(this->distribution().block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
adjacency_list(vertices_size_type n,
const ProcessGroup& pg = ProcessGroup())
: named_graph_mixin(pg, default_distribution_type(pg, n)),
m_local_graph(this->distribution().block_size(process_id(pg), n),
GraphProperty()),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
/*
* We assume that every processor sees the same list of edges, so
* they skip over any that don't originate from themselves. This
* means that programs switching between a local and a distributed
* graph will keep the same semantics.
*/
template <class EdgeIterator>
adjacency_list(EdgeIterator first, EdgeIterator last,
vertices_size_type n,
const ProcessGroup& pg = ProcessGroup(),
const GraphProperty& p = GraphProperty())
: named_graph_mixin(pg, default_distribution_type(pg, n)),
m_local_graph(this->distribution().block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
typedef typename config_type::VertexListS vertex_list_selector;
initialize(first, last, n, this->distribution(), vertex_list_selector());
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
template <class EdgeIterator, class EdgePropertyIterator>
adjacency_list(EdgeIterator first, EdgeIterator last,
EdgePropertyIterator ep_iter,
vertices_size_type n,
const ProcessGroup& pg = ProcessGroup(),
const GraphProperty& p = GraphProperty())
: named_graph_mixin(pg, default_distribution_type(pg, n)),
m_local_graph(this->distribution().block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
typedef typename config_type::VertexListS vertex_list_selector;
initialize(first, last, ep_iter, n, this->distribution(),
vertex_list_selector());
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
template <class EdgeIterator>
adjacency_list(EdgeIterator first, EdgeIterator last,
vertices_size_type n,
const ProcessGroup& pg,
const base_distribution_type& distribution,
const GraphProperty& p = GraphProperty())
: named_graph_mixin(pg, distribution),
m_local_graph(distribution.block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
typedef typename config_type::VertexListS vertex_list_selector;
initialize(first, last, n, this->distribution(), vertex_list_selector());
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
template <class EdgeIterator, class EdgePropertyIterator>
adjacency_list(EdgeIterator first, EdgeIterator last,
EdgePropertyIterator ep_iter,
vertices_size_type n,
const ProcessGroup& pg,
const base_distribution_type& distribution,
const GraphProperty& p = GraphProperty())
: named_graph_mixin(pg, distribution),
m_local_graph(this->distribution().block_size(process_id(pg), n), p),
process_group_(pg, graph::parallel::attach_distributed_object())
{
setup_triggers();
typedef typename config_type::VertexListS vertex_list_selector;
initialize(first, last, ep_iter, n, distribution,
vertex_list_selector());
detail::parallel::maybe_initialize_vertex_indices(vertices(base()),
get(vertex_index, base()));
}
~adjacency_list()
{
synchronize(process_group_);
}
void clear()
{
base().clear();
local_edges_.clear();
named_graph_mixin::clearing_graph();
}
void swap(adjacency_list& other)
{
using std::swap;
base().swap(other);
swap(process_group_, other.process_group_);
}
static vertex_descriptor null_vertex()
{
return vertex_descriptor(processor_id_type(0),
inherited::null_vertex());
}
inherited& base() { return m_local_graph; }
const inherited& base() const { return m_local_graph; }
processor_id_type processor() const { return process_id(process_group_); }
process_group_type process_group() const { return process_group_.base(); }
local_edge_list_type& local_edges() { return local_edges_; }
const local_edge_list_type& local_edges() const { return local_edges_; }
// Redistribute the vertices of the graph by placing each vertex
// v on the processor get(vertex_to_processor, v).
template<typename VertexProcessorMap>
void redistribute(VertexProcessorMap vertex_to_processor);
// Directly access a vertex or edge bundle
vertex_bundled& operator[](vertex_descriptor v)
{
BOOST_ASSERT(v.owner == processor());
return base()[v.local];
}
const vertex_bundled& operator[](vertex_descriptor v) const
{
BOOST_ASSERT(v.owner == processor());
return base()[v.local];
}
edge_bundled& operator[](edge_descriptor e)
{
BOOST_ASSERT(e.owner() == processor());
return base()[e.local];
}
const edge_bundled& operator[](edge_descriptor e) const
{
BOOST_ASSERT(e.owner() == processor());
return base()[e.local];
}
graph_bundled& operator[](graph_bundle_t)
{ return get_property(*this); }
graph_bundled const& operator[](graph_bundle_t) const
{ return get_property(*this); }
template<typename OStreamConstructibleArchive>
void save(std::string const& filename) const;
template<typename IStreamConstructibleArchive>
void load(std::string const& filename);
// Callback that will be invoked whenever a new vertex is added locally
boost::function<void(vertex_descriptor, adjacency_list&)> on_add_vertex;
// Callback that will be invoked whenever a new edge is added locally
boost::function<void(edge_descriptor, adjacency_list&)> on_add_edge;
private:
// Request vertex->processor mapping for neighbors <does nothing>
template<typename VertexProcessorMap>
void
request_in_neighbors(vertex_descriptor,
VertexProcessorMap,
directedS) { }
// Request vertex->processor mapping for neighbors <does nothing>
template<typename VertexProcessorMap>
void
request_in_neighbors(vertex_descriptor,
VertexProcessorMap,
undirectedS) { }
// Request vertex->processor mapping for neighbors
template<typename VertexProcessorMap>
void
request_in_neighbors(vertex_descriptor v,
VertexProcessorMap vertex_to_processor,
bidirectionalS);
// Clear the list of in-edges, but don't tell the remote processor
void clear_in_edges_local(vertex_descriptor v, directedS) {}
void clear_in_edges_local(vertex_descriptor v, undirectedS) {}
void clear_in_edges_local(vertex_descriptor v, bidirectionalS)
{ get(vertex_in_edges, base())[v.local].clear(); }
// Remove in-edges that have migrated <does nothing>
template<typename VertexProcessorMap>
void
remove_migrated_in_edges(vertex_descriptor,
VertexProcessorMap,
directedS) { }
// Remove in-edges that have migrated <does nothing>
template<typename VertexProcessorMap>
void
remove_migrated_in_edges(vertex_descriptor,
VertexProcessorMap,
undirectedS) { }
// Remove in-edges that have migrated
template<typename VertexProcessorMap>
void
remove_migrated_in_edges(vertex_descriptor v,
VertexProcessorMap vertex_to_processor,
bidirectionalS);
// Initialize the graph with the given edge list and vertex
// distribution. This variation works only when
// VertexListS=vecS, and we know how to create remote vertex
// descriptors based solely on the distribution.
template<typename EdgeIterator>
void
initialize(EdgeIterator first, EdgeIterator last,
vertices_size_type, const base_distribution_type& distribution,
vecS);
// Initialize the graph with the given edge list, edge
// properties, and vertex distribution. This variation works
// only when VertexListS=vecS, and we know how to create remote
// vertex descriptors based solely on the distribution.
template<typename EdgeIterator, typename EdgePropertyIterator>
void
initialize(EdgeIterator first, EdgeIterator last,
EdgePropertyIterator ep_iter,
vertices_size_type, const base_distribution_type& distribution,
vecS);
// Initialize the graph with the given edge list, edge
// properties, and vertex distribution.
template<typename EdgeIterator, typename EdgePropertyIterator,
typename VertexListS>
void
initialize(EdgeIterator first, EdgeIterator last,
EdgePropertyIterator ep_iter,
vertices_size_type n,
const base_distribution_type& distribution,
VertexListS);
// Initialize the graph with the given edge list and vertex
// distribution. This is nearly identical to the one below it,
// for which I should be flogged. However, this version does use
// slightly less memory than the version that accepts an edge
// property iterator.
template<typename EdgeIterator, typename VertexListS>
void
initialize(EdgeIterator first, EdgeIterator last,
vertices_size_type n,
const base_distribution_type& distribution,
VertexListS);
public:
//---------------------------------------------------------------------
// Build a vertex property instance for the underlying adjacency
// list from the given property instance of the type exposed to
// the user.
base_vertex_property_type
build_vertex_property(const vertex_property_type& p)
{ return build_vertex_property(p, directed_selector()); }
base_vertex_property_type
build_vertex_property(const vertex_property_type& p, directedS)
{
return base_vertex_property_type(p);
}
base_vertex_property_type
build_vertex_property(const vertex_property_type& p, bidirectionalS)
{
return base_vertex_property_type(in_edge_list_type(), p);
}
base_vertex_property_type
build_vertex_property(const vertex_property_type& p, undirectedS)
{
return base_vertex_property_type(p);
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// Build an edge property instance for the underlying adjacency
// list from the given property instance of the type exposed to
// the user.
base_edge_property_type build_edge_property(const edge_property_type& p)
{ return build_edge_property(p, directed_selector()); }
base_edge_property_type
build_edge_property(const edge_property_type& p, directedS)
{
return base_edge_property_type(0, p);
}
base_edge_property_type
build_edge_property(const edge_property_type& p, bidirectionalS)
{
return base_edge_property_type(0, p);
}
base_edge_property_type
build_edge_property(const edge_property_type& p, undirectedS)
{
typedef typename base_edge_property_type::next_type
edge_property_with_id;
return base_edge_property_type(true, edge_property_with_id(0, p));
}
//---------------------------------------------------------------------
/** The set of messages that can be transmitted and received by
* a distributed adjacency list. This list will eventually be
* exhaustive, but is currently quite limited.
*/
enum {
/**
* Request to add or find a vertex with the given vertex
* property. The data will be a vertex_property_type
* structure.
*/
msg_add_vertex_with_property = 0,
/**
* Request to add or find a vertex with the given vertex
* property, and request that the remote processor return the
* descriptor for the added/found edge. The data will be a
* vertex_property_type structure.
*/
msg_add_vertex_with_property_and_reply,
/**
* Reply to a msg_add_vertex_* message, containing the local
* vertex descriptor that was added or found.
*/
msg_add_vertex_reply,
/**
* Request to add an edge remotely. The data will be a
* msg_add_edge_data structure.
*/
msg_add_edge,
/**
* Request to add an edge remotely. The data will be a
* msg_add_edge_with_property_data structure.
*/
msg_add_edge_with_property,
/**
* Request to add an edge remotely and reply back with the
* edge descriptor. The data will be a
* msg_add_edge_data structure.
*/
msg_add_edge_with_reply,
/**
* Request to add an edge remotely and reply back with the
* edge descriptor. The data will be a
* msg_add_edge_with_property_data structure.
*/
msg_add_edge_with_property_and_reply,
/**
* Reply message responding to an @c msg_add_edge_with_reply
* or @c msg_add_edge_with_property_and_reply messages. The
* data will be a std::pair<edge_descriptor, bool>.
*/
msg_add_edge_reply,
/**
* Indicates that a nonlocal edge has been created that should
* be added locally. Only valid for bidirectional and
* undirected graphs. The message carries a
* msg_nonlocal_edge_data structure.
*/
msg_nonlocal_edge,
/**
* Indicates that a remote edge should be removed. This
* message does not exist for directedS graphs but may refer
* to either in-edges or out-edges for undirectedS graphs.
*/
msg_remove_edge,
/**
* Indicates the number of vertices and edges that will be
* relocated from the source processor to the target
* processor. The data will be a pair<vertices_size_type,
* edges_size_type>.
*/
msg_num_relocated
};
typedef detail::parallel::msg_add_edge_data<vertex_descriptor,
local_vertex_descriptor>
msg_add_edge_data;
typedef detail::parallel::msg_add_edge_with_property_data
<vertex_descriptor, local_vertex_descriptor,
edge_property_type> msg_add_edge_with_property_data;
typedef boost::detail::parallel::msg_nonlocal_edge_data<
edge_property_type,local_edge_descriptor> msg_nonlocal_edge_data;
typedef boost::detail::parallel::msg_remove_edge_data<edge_descriptor>
msg_remove_edge_data;
void send_remove_edge_request(edge_descriptor e)
{
process_id_type dest = e.target_processor;
if (e.target_processor == process_id(process_group_))
dest = e.source_processor;
send(process_group_, dest, msg_remove_edge, msg_remove_edge_data(e));
}
/// Process incoming messages.
void setup_triggers();
void
handle_add_vertex_with_property(int source, int tag,
const vertex_property_type&,
trigger_receive_context);
local_vertex_descriptor
handle_add_vertex_with_property_and_reply(int source, int tag,
const vertex_property_type&,
trigger_receive_context);
void
handle_add_edge(int source, int tag, const msg_add_edge_data& data,
trigger_receive_context);
boost::parallel::detail::untracked_pair<edge_descriptor, bool>
handle_add_edge_with_reply(int source, int tag,
const msg_add_edge_data& data,
trigger_receive_context);
void
handle_add_edge_with_property(int source, int tag,
const msg_add_edge_with_property_data&,
trigger_receive_context);
boost::parallel::detail::untracked_pair<edge_descriptor, bool>
handle_add_edge_with_property_and_reply
(int source, int tag, const msg_add_edge_with_property_data&,
trigger_receive_context);
void
handle_nonlocal_edge(int source, int tag,
const msg_nonlocal_edge_data& data,
trigger_receive_context);
void
handle_remove_edge(int source, int tag,
const msg_remove_edge_data& data,
trigger_receive_context);
protected:
/** Add an edge (locally) that was received from another
* processor. This operation is a no-op for directed graphs,
* because all edges reside on the local processor. For
* bidirectional graphs, this routine places the edge onto the
* list of incoming edges for the target vertex. For undirected
* graphs, the edge is placed along with all of the other edges
* for the target vertex, but it is marked as a non-local edge
* descriptor.
*
* \todo There is a potential problem here, where we could
* unintentionally allow duplicate edges in undirected graphs
* because the same edge is added on two different processors
* simultaneously. It's not an issue now, because we require
* that the graph allow parallel edges. Once we do support
* containers such as setS or hash_setS that disallow parallel
* edges we will need to deal with this.
*/
void
add_remote_edge(const msg_nonlocal_edge_data&,
processor_id_type, directedS)
{ }
/**
* \overload
*/
void
add_remote_edge(const msg_nonlocal_edge_data& data,
processor_id_type other_proc, bidirectionalS)
{
typedef detail::parallel::stored_in_edge<local_edge_descriptor> stored_edge;
stored_edge edge(other_proc, data.e);
local_vertex_descriptor v = target(data.e, base());
boost::graph_detail::push(get(vertex_in_edges, base())[v], edge);
}
/**
* \overload
*/
void
add_remote_edge(const msg_nonlocal_edge_data& data,
processor_id_type other_proc, undirectedS)
{
std::pair<local_edge_descriptor, bool> edge =
detail::parallel::add_local_edge(target(data.e, base()),
source(data.e, base()),
build_edge_property(data.get_property()), base());
BOOST_ASSERT(edge.second);
put(edge_target_processor_id, base(), edge.first, other_proc);
if (edge.second && on_add_edge)
on_add_edge(edge_descriptor(processor(), other_proc, false,
edge.first),
*this);
}
void
remove_local_edge(const msg_remove_edge_data&, processor_id_type,
directedS)
{ }
void
remove_local_edge(const msg_remove_edge_data& data,
processor_id_type other_proc, bidirectionalS)
{
/* When the source is local, we first check if the edge still
* exists (it may have been deleted locally) and, if so,
* remove it locally.
*/
vertex_descriptor src = source(data.e, *this);
vertex_descriptor tgt = target(data.e, *this);
if (src.owner == process_id(process_group_)) {
base_out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(src.local, base());
ei != ei_end; ++ei) {
// TBD: can't check the descriptor here, because it could
// have changed if we're allowing the removal of
// edges. Egads!
if (tgt.local == target(*ei, base())
&& get(edge_target_processor_id, base(), *ei) == other_proc)
break;
}
if (ei != ei_end) boost::remove_edge(ei, base());
remove_local_edge_from_list(src, tgt, undirectedS());
} else {
BOOST_ASSERT(tgt.owner == process_id(process_group_));
in_edge_list_type& in_edges =
get(vertex_in_edges, base())[tgt.local];
typename in_edge_list_type::iterator ei;
for (ei = in_edges.begin(); ei != in_edges.end(); ++ei) {
if (src.local == source(ei->e, base())
&& src.owner == ei->source_processor)
break;
}
if (ei != in_edges.end()) in_edges.erase(ei);
}
}
void
remove_local_edge(const msg_remove_edge_data& data,
processor_id_type other_proc, undirectedS)
{
vertex_descriptor local_vertex = source(data.e, *this);
vertex_descriptor remote_vertex = target(data.e, *this);
if (remote_vertex.owner == process_id(process_group_)) {
using std::swap;
swap(local_vertex, remote_vertex);
}
// Remove the edge from the out-edge list, if it is there
{
base_out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(local_vertex.local, base());
ei != ei_end; ++ei) {
// TBD: can't check the descriptor here, because it could
// have changed if we're allowing the removal of
// edges. Egads!
if (remote_vertex.local == target(*ei, base())
&& get(edge_target_processor_id, base(), *ei) == other_proc)
break;
}
if (ei != ei_end) boost::remove_edge(ei, base());
}
remove_local_edge_from_list(local_vertex, remote_vertex, undirectedS());
}
public:
void
remove_local_edge_from_list(vertex_descriptor, vertex_descriptor,
directedS)
{
}
void
remove_local_edge_from_list(vertex_descriptor, vertex_descriptor,
bidirectionalS)
{
}
void
remove_local_edge_from_list(vertex_descriptor src, vertex_descriptor tgt,
undirectedS)
{
// TBD: At some point we'll be able to improve the speed here
// because we'll know when the edge can't be in the local
// list.
{
typename local_edge_list_type::iterator ei;
for (ei = local_edges_.begin(); ei != local_edges_.end(); ++ei) {
if ((source(*ei, *this) == src
&& target(*ei, *this) == tgt)
|| (source(*ei, *this) == tgt
&& target(*ei, *this) == src))
break;
}
if (ei != local_edges_.end()) local_edges_.erase(ei);
}
}
private:
/// The local subgraph
inherited m_local_graph;
/// The process group through which this distributed graph
/// communicates.
process_group_type process_group_;
// TBD: should only be available for undirected graphs, but for
// now it'll just be empty for directed and bidirectional
// graphs.
local_edge_list_type local_edges_;
};
//------------------------------------------------------------------------
// Lazy addition of vertices
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
struct PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_vertex_with_property
{
/// Construct a lazy request to add a vertex
lazy_add_vertex_with_property(adjacency_list& self,
const vertex_property_type& property)
: self(self), property(property), committed(false) { }
/// Copying a lazy_add_vertex_with_property transfers the
/// responsibility for adding the vertex to the newly-constructed
/// object.
lazy_add_vertex_with_property(const lazy_add_vertex_with_property& other)
: self(other.self), property(other.property),
committed(other.committed)
{
other.committed = true;
}
/// If the vertex has not yet been added, add the vertex but don't
/// wait for a reply.
~lazy_add_vertex_with_property();
/// Returns commit().
operator vertex_descriptor() const { return commit(); }
// Add the vertex. This operation will block if the vertex is
// being added remotely.
vertex_descriptor commit() const;
protected:
adjacency_list& self;
vertex_property_type property;
mutable bool committed;
private:
// No copy-assignment semantics
void operator=(lazy_add_vertex_with_property&);
};
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_vertex_with_property::
~lazy_add_vertex_with_property()
{
/// If this vertex has already been created or will be created by
/// someone else, or if someone threw an exception, we will not
/// create the vertex now.
if (committed || std::uncaught_exception())
return;
committed = true;
process_id_type owner
= static_cast<graph_type&>(self).owner_by_property(property);
if (owner == self.processor()) {
/// Add the vertex locally.
vertex_descriptor v(owner,
add_vertex(self.build_vertex_property(property),
self.base()));
if (self.on_add_vertex)
self.on_add_vertex(v, self);
}
else
/// Ask the owner of this new vertex to add the vertex. We
/// don't need a reply.
send(self.process_group_, owner, msg_add_vertex_with_property,
property);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_vertex_with_property::
commit() const
{
BOOST_ASSERT(!this->committed);
this->committed = true;
process_id_type owner
= static_cast<graph_type&>(self).owner_by_property(property);
local_vertex_descriptor local_v;
if (owner == self.processor())
/// Add the vertex locally.
local_v = add_vertex(self.build_vertex_property(property),
self.base());
else {
// Request that the remote process add the vertex immediately
send_oob_with_reply(self.process_group_, owner,
msg_add_vertex_with_property_and_reply, property,
local_v);
}
vertex_descriptor v(owner, local_v);
if (self.on_add_vertex)
self.on_add_vertex(v, self);
// Build the full vertex descriptor to return
return v;
}
/**
* Data structure returned from add_edge that will "lazily" add
* the edge, either when it is converted to a
* @c pair<edge_descriptor, bool> or when the most recent copy has
* been destroyed.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
struct PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge
{
/// Construct a lazy request to add an edge
lazy_add_edge(adjacency_list& self,
vertex_descriptor source, vertex_descriptor target)
: self(self), source(source), target(target), committed(false) { }
/// Copying a lazy_add_edge transfers the responsibility for
/// adding the edge to the newly-constructed object.
lazy_add_edge(const lazy_add_edge& other)
: self(other.self), source(other.source), target(other.target),
committed(other.committed)
{
other.committed = true;
}
/// If the edge has not yet been added, add the edge but don't
/// wait for a reply.
~lazy_add_edge();
/// Returns commit().
operator std::pair<edge_descriptor, bool>() const { return commit(); }
// Add the edge. This operation will block if a remote edge is
// being added.
std::pair<edge_descriptor, bool> commit() const;
protected:
std::pair<edge_descriptor, bool>
add_local_edge(const edge_property_type& property, directedS) const;
std::pair<edge_descriptor, bool>
add_local_edge(const edge_property_type& property, bidirectionalS) const;
std::pair<edge_descriptor, bool>
add_local_edge(const edge_property_type& property, undirectedS) const;
adjacency_list& self;
vertex_descriptor source;
vertex_descriptor target;
mutable bool committed;
private:
// No copy-assignment semantics
void operator=(lazy_add_edge&);
};
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge::~lazy_add_edge()
{
/// If this edge has already been created or will be created by
/// someone else, or if someone threw an exception, we will not
/// create the edge now.
if (committed || std::uncaught_exception())
return;
committed = true;
if (source.owner == self.processor())
this->add_local_edge(edge_property_type(), DirectedS());
else
// Request that the remote processor add an edge and, but
// don't wait for a reply.
send(self.process_group_, source.owner, msg_add_edge,
msg_add_edge_data(source, target));
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor, bool>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge::commit() const
{
BOOST_ASSERT(!committed);
committed = true;
if (source.owner == self.processor())
return this->add_local_edge(edge_property_type(), DirectedS());
else {
// Request that the remote processor add an edge
boost::parallel::detail::untracked_pair<edge_descriptor, bool> result;
send_oob_with_reply(self.process_group_, source.owner,
msg_add_edge_with_reply,
msg_add_edge_data(source, target), result);
return result;
}
}
// Add a local edge into a directed graph
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor, bool>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge::
add_local_edge(const edge_property_type& property, directedS) const
{
// Add the edge to the local part of the graph
std::pair<local_edge_descriptor, bool> inserted =
detail::parallel::add_local_edge(source.local, target.local,
self.build_edge_property(property),
self.base());
if (inserted.second)
// Keep track of the owner of the target
put(edge_target_processor_id, self.base(), inserted.first,
target.owner);
// Compose the edge descriptor and return the result
edge_descriptor e(source.owner, target.owner, true, inserted.first);
// Trigger the on_add_edge event
if (inserted.second && self.on_add_edge)
self.on_add_edge(e, self);
return std::pair<edge_descriptor, bool>(e, inserted.second);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor, bool>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge::
add_local_edge(const edge_property_type& property, bidirectionalS) const
{
// Add the directed edge.
std::pair<edge_descriptor, bool> result
= this->add_local_edge(property, directedS());
if (result.second) {
if (target.owner == self.processor()) {
// Edge is local, so add the stored edge to the in_edges list
typedef detail::parallel::stored_in_edge<local_edge_descriptor>
stored_edge;
stored_edge e(self.processor(), result.first.local);
boost::graph_detail::push(get(vertex_in_edges,
self.base())[target.local], e);
}
else {
// Edge is remote, so notify the target's owner that an edge
// has been added.
if (self.process_group_.trigger_context() == graph::parallel::trc_out_of_band)
send_oob(self.process_group_, target.owner, msg_nonlocal_edge,
msg_nonlocal_edge_data(result.first.local, property));
else
send(self.process_group_, target.owner, msg_nonlocal_edge,
msg_nonlocal_edge_data(result.first.local, property));
}
}
return result;
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor, bool>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge::
add_local_edge(const edge_property_type& property, undirectedS) const
{
// Add the directed edge
std::pair<edge_descriptor, bool> result
= this->add_local_edge(property, directedS());
typedef detail::parallel::stored_in_edge<local_edge_descriptor>
stored_edge;
if (result.second) {
if (target.owner == self.processor()) {
// Edge is local, so add the new edge to the list
// TODO: This is not what we want to do for an undirected
// edge, because we haven't linked the source and target's
// representations of those edges.
local_edge_descriptor return_edge =
detail::parallel::add_local_edge(target.local, source.local,
self.build_edge_property(property),
self.base()).first;
put(edge_target_processor_id, self.base(), return_edge,
source.owner);
}
else {
// Edge is remote, so notify the target's owner that an edge
// has been added.
if (self.process_group_.trigger_context() == graph::parallel::trc_out_of_band)
send_oob(self.process_group_, target.owner, msg_nonlocal_edge,
msg_nonlocal_edge_data(result.first.local, property));
else
send(self.process_group_, target.owner, msg_nonlocal_edge,
msg_nonlocal_edge_data(result.first.local, property));
}
// Add this edge to the list of local edges
graph_detail::push(self.local_edges(), result.first);
}
return result;
}
/**
* Data structure returned from add_edge that will "lazily" add
* the edge with its property, either when it is converted to a
* pair<edge_descriptor, bool> or when the most recent copy has
* been destroyed.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
struct PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge_with_property
: lazy_add_edge
{
/// Construct a lazy request to add an edge
lazy_add_edge_with_property(adjacency_list& self,
vertex_descriptor source,
vertex_descriptor target,
const edge_property_type& property)
: lazy_add_edge(self, source, target), property(property) { }
/// Copying a lazy_add_edge transfers the responsibility for
/// adding the edge to the newly-constructed object.
lazy_add_edge_with_property(const lazy_add_edge& other)
: lazy_add_edge(other), property(other.property) { }
/// If the edge has not yet been added, add the edge but don't
/// wait for a reply.
~lazy_add_edge_with_property();
/// Returns commit().
operator std::pair<edge_descriptor, bool>() const { return commit(); }
// Add the edge. This operation will block if a remote edge is
// being added.
std::pair<edge_descriptor, bool> commit() const;
private:
// No copy-assignment semantics
void operator=(lazy_add_edge_with_property&);
edge_property_type property;
};
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge_with_property::
~lazy_add_edge_with_property()
{
/// If this edge has already been created or will be created by
/// someone else, or if someone threw an exception, we will not
/// create the edge now.
if (this->committed || std::uncaught_exception())
return;
this->committed = true;
if (this->source.owner == this->self.processor())
// Add a local edge
this->add_local_edge(property, DirectedS());
else
// Request that the remote processor add an edge and, but
// don't wait for a reply.
send(this->self.process_group_, this->source.owner,
msg_add_edge_with_property,
msg_add_edge_with_property_data(this->source, this->target,
property));
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor, bool>
PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge_with_property::
commit() const
{
BOOST_ASSERT(!this->committed);
this->committed = true;
if (this->source.owner == this->self.processor())
// Add a local edge
return this->add_local_edge(property, DirectedS());
else {
// Request that the remote processor add an edge
boost::parallel::detail::untracked_pair<edge_descriptor, bool> result;
send_oob_with_reply(this->self.process_group_, this->source.owner,
msg_add_edge_with_property_and_reply,
msg_add_edge_with_property_data(this->source,
this->target,
property),
result);
return result;
}
}
/**
* Returns the set of vertices local to this processor. Note that
* although this routine matches a valid expression of a
* VertexListGraph, it does not meet the semantic requirements of
* VertexListGraph because it returns only local vertices (not all
* vertices).
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_iterator>
vertices(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_descriptor Vertex;
typedef typename Vertex::generator generator;
return std::make_pair(make_transform_iterator(vertices(g.base()).first,
generator(g.processor())),
make_transform_iterator(vertices(g.base()).second,
generator(g.processor())));
}
/**
* Returns the number of vertices local to this processor. Note that
* although this routine matches a valid expression of a
* VertexListGraph, it does not meet the semantic requirements of
* VertexListGraph because it returns only a count of local vertices
* (not all vertices).
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE
::vertices_size_type
num_vertices(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
return num_vertices(g.base());
}
/***************************************************************************
* Implementation of Incidence Graph concept
***************************************************************************/
/**
* Returns the source of edge @param e in @param g.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename Edge>
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
source(const detail::parallel::edge_descriptor<Edge>& e,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_descriptor Vertex;
return Vertex(e.source_processor, source(e.local, g.base()));
}
/**
* Returns the target of edge @param e in @param g.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename Edge>
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
target(const detail::parallel::edge_descriptor<Edge>& e,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_descriptor Vertex;
return Vertex(e.target_processor, target(e.local, g.base()));
}
/**
* Return the set of edges outgoing from a particular vertex. The
* vertex @param v must be local to the processor executing this
* routine.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::out_edge_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE::out_edge_iterator>
out_edges(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
BOOST_ASSERT(v.owner == g.processor());
typedef PBGL_DISTRIB_ADJLIST_TYPE impl;
typedef typename impl::out_edge_generator generator;
return std::make_pair(
make_transform_iterator(out_edges(v.local, g.base()).first,
generator(g)),
make_transform_iterator(out_edges(v.local, g.base()).second,
generator(g)));
}
/**
* Return the number of edges outgoing from a particular vertex. The
* vertex @param v must be local to the processor executing this
* routine.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::degree_size_type
out_degree(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
BOOST_ASSERT(v.owner == g.processor());
return out_degree(v.local, g.base());
}
/***************************************************************************
* Implementation of Bidirectional Graph concept
***************************************************************************/
/**
* Returns the set of edges incoming to a particular vertex. The
* vertex @param v must be local to the processor executing this
* routine.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::in_edge_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::in_edge_iterator>
in_edges(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS) impl;
typedef typename impl::inherited base_graph_type;
typedef typename impl::in_edge_generator generator;
typename property_map<base_graph_type, vertex_in_edges_t>::const_type
in_edges = get(vertex_in_edges, g.base());
return std::make_pair(make_transform_iterator(in_edges[v.local].begin(),
generator(g)),
make_transform_iterator(in_edges[v.local].end(),
generator(g)));
}
/**
* \overload
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::in_edge_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::in_edge_iterator>
in_edges(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS) impl;
typedef typename impl::in_edge_generator generator;
return std::make_pair(
make_transform_iterator(out_edges(v.local, g.base()).first,
generator(g)),
make_transform_iterator(out_edges(v.local, g.base()).second,
generator(g)));
}
/**
* Returns the number of edges incoming to a particular vertex. The
* vertex @param v must be local to the processor executing this
* routine.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)::degree_size_type
in_degree(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
return get(vertex_in_edges, g.base())[v.local].size();
}
/**
* \overload
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)::degree_size_type
in_degree(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
return out_degree(v.local, g.base());
}
/**
* Returns the number of edges incident on the given vertex. The
* vertex @param v must be local to the processor executing this
* routine.
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::degree_size_type
degree(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
return out_degree(v.local, g.base());
}
/**
* \overload
*/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::degree_size_type
degree(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
BOOST_ASSERT(v.owner == g.processor());
return out_degree(v, g) + in_degree(v, g);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::edges_size_type
num_edges(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
return num_edges(g.base());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)::edges_size_type
num_edges(const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
return g.local_edges().size();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<
typename PBGL_DISTRIB_ADJLIST_TYPE::edge_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE::edge_iterator>
edges(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE impl;
typedef typename impl::out_edge_generator generator;
return std::make_pair(make_transform_iterator(edges(g.base()).first,
generator(g)),
make_transform_iterator(edges(g.base()).second,
generator(g)));
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
std::pair<
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)::edge_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)::edge_iterator>
edges(const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
return std::make_pair(g.local_edges().begin(), g.local_edges().end());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
vertex(typename PBGL_DISTRIB_ADJLIST_TYPE::vertices_size_type n,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
vertex_descriptor;
return vertex_descriptor(g.distribution()(n), g.distribution().local(n));
}
/***************************************************************************
* Access to particular edges
***************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
std::pair<
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)::edge_descriptor,
bool
>
edge(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)::vertex_descriptor u,
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)
::edge_descriptor edge_descriptor;
// For directed graphs, u must be local
BOOST_ASSERT(u.owner == process_id(g.process_group()));
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)
::out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (target(*ei, g) == v) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<
typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor,
bool
>
edge(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::edge_descriptor edge_descriptor;
// For bidirectional and undirected graphs, u must be local or v
// must be local
if (u.owner == process_id(g.process_group())) {
typename PBGL_DISTRIB_ADJLIST_TYPE::out_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (target(*ei, g) == v) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
} else if (v.owner == process_id(g.process_group())) {
typename PBGL_DISTRIB_ADJLIST_TYPE::in_edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = in_edges(v, g); ei != ei_end; ++ei) {
if (source(*ei, g) == u) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
} else {
BOOST_ASSERT(false);
abort();
}
}
#if 0
// TBD: not yet supported
std::pair<out_edge_iterator, out_edge_iterator>
edge_range(vertex_descriptor u, vertex_descriptor v,
const adjacency_list& g);
#endif
/***************************************************************************
* Implementation of Adjacency Graph concept
***************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
std::pair<typename PBGL_DISTRIB_ADJLIST_TYPE::adjacency_iterator,
typename PBGL_DISTRIB_ADJLIST_TYPE::adjacency_iterator>
adjacent_vertices(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE::adjacency_iterator iter;
return std::make_pair(iter(out_edges(v, g).first, &g),
iter(out_edges(v, g).second, &g));
}
/***************************************************************************
* Implementation of Mutable Graph concept
***************************************************************************/
/************************************************************************
* add_edge
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge
add_edge(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_edge lazy_add_edge;
return lazy_add_edge(g, u, v);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE
::lazy_add_edge_with_property
add_edge(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
typename PBGL_DISTRIB_ADJLIST_TYPE::edge_property_type const& p,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::lazy_add_edge_with_property lazy_add_edge_with_property;
return lazy_add_edge_with_property(g, u, v, p);
}
/************************************************************************
*
* remove_edge
*
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
void
remove_edge(typename PBGL_DISTRIB_ADJLIST_TYPE::edge_descriptor e,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
BOOST_ASSERT(source(e, g).owner == g.processor()
|| target(e, g).owner == g.processor());
if (target(e, g).owner == g.processor())
detail::parallel::remove_in_edge(e, g, DirectedS());
if (source(e, g).owner == g.processor())
remove_edge(e.local, g.base());
g.remove_local_edge_from_list(source(e, g), target(e, g), DirectedS());
if (source(e, g).owner != g.processor()
|| (target(e, g).owner != g.processor()
&& !(is_same<DirectedS, directedS>::value))) {
g.send_remove_edge_request(e);
}
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
void
remove_edge(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::vertex_descriptor vertex_descriptor;
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::edge_descriptor edge_descriptor;
std::pair<edge_descriptor, bool> the_edge = edge(u, v, g);
if (the_edge.second) remove_edge(the_edge.first, g);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline void
remove_edge(typename PBGL_DISTRIB_ADJLIST_TYPE::out_edge_iterator ei,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
remove_edge(*ei, g);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
inline void
remove_edge(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)
::out_edge_iterator ei,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)& g)
{
BOOST_ASSERT(source(*ei, g).owner == g.processor());
remove_edge(ei->local, g.base());
}
/************************************************************************
*
* remove_out_edge_if
*
************************************************************************/
namespace parallel { namespace detail {
/**
* Function object that applies the underlying predicate to
* determine if an out-edge should be removed. If so, either
* removes the incoming edge (if it is stored locally) or sends a
* message to the owner of the target requesting that it remove
* the edge.
*/
template<typename Graph, typename Predicate>
struct remove_out_edge_predicate
{
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef typename Graph::local_edge_descriptor argument_type;
typedef typename Graph::directed_selector directed_selector;
typedef bool result_type;
remove_out_edge_predicate(Graph& g, Predicate& predicate)
: g(g), predicate(predicate) { }
bool operator()(const argument_type& le)
{
typedef typename edge_descriptor::template out_generator<Graph>
generator;
edge_descriptor e = generator(g)(le);
if (predicate(e)) {
if (source(e, g).owner != target(e, g).owner
&& !(is_same<directed_selector, directedS>::value))
g.send_remove_edge_request(e);
else
::boost::detail::parallel::remove_in_edge(e, g,
directed_selector());
g.remove_local_edge_from_list(source(e, g), target(e, g),
directed_selector());
return true;
} else return false;
}
private:
Graph& g;
Predicate predicate;
};
} } // end namespace parallel::detail
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename Predicate>
inline void
remove_out_edge_if
(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE Graph;
typedef parallel::detail::remove_out_edge_predicate<Graph, Predicate>
Pred;
BOOST_ASSERT(u.owner == g.processor());
remove_out_edge_if(u.local, Pred(g, predicate), g.base());
}
/************************************************************************
*
* remove_in_edge_if
*
************************************************************************/
namespace parallel { namespace detail {
/**
* Function object that applies the underlying predicate to
* determine if an in-edge should be removed. If so, either
* removes the outgoing edge (if it is stored locally) or sends a
* message to the owner of the target requesting that it remove
* the edge. Only required for bidirectional graphs.
*/
template<typename Graph, typename Predicate>
struct remove_in_edge_predicate
{
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef bool result_type;
remove_in_edge_predicate(Graph& g, const Predicate& predicate)
: g(g), predicate(predicate) { }
template<typename StoredEdge>
bool operator()(const StoredEdge& le)
{
typedef typename edge_descriptor::template in_generator<Graph>
generator;
edge_descriptor e = generator(g)(le);
if (predicate(e)) {
if (source(e, g).owner != target(e, g).owner)
g.send_remove_edge_request(e);
else
remove_edge(source(e, g).local, target(e, g).local, g.base());
return true;
} else return false;
}
private:
Graph& g;
Predicate predicate;
};
} } // end namespace parallel::detail
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG, typename Predicate>
inline void
remove_in_edge_if
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor u,
Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS) Graph;
typedef parallel::detail::remove_in_edge_predicate<Graph, Predicate>
Pred;
BOOST_ASSERT(u.owner == g.processor());
graph_detail::erase_if(get(vertex_in_edges, g.base())[u.local],
Pred(g, predicate));
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG, typename Predicate>
inline void
remove_in_edge_if
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::vertex_descriptor u,
Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
remove_out_edge_if(u, predicate, g);
}
/************************************************************************
*
* remove_edge_if
*
************************************************************************/
namespace parallel { namespace detail {
/**
* Function object that applies the underlying predicate to
* determine if a directed edge can be removed. This only applies
* to directed graphs.
*/
template<typename Graph, typename Predicate>
struct remove_directed_edge_predicate
{
typedef typename Graph::local_edge_descriptor argument_type;
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef bool result_type;
remove_directed_edge_predicate(Graph& g, const Predicate& predicate)
: g(g), predicate(predicate) { }
bool operator()(const argument_type& le)
{
typedef typename edge_descriptor::template out_generator<Graph>
generator;
edge_descriptor e = generator(g)(le);
return predicate(e);
}
private:
Graph& g;
Predicate predicate;
};
} } // end namespace parallel::detail
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG, typename Predicate>
inline void
remove_edge_if(Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS) Graph;
typedef parallel::detail::remove_directed_edge_predicate<Graph,
Predicate> Pred;
remove_edge_if(Pred(g, predicate), g.base());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG, typename Predicate>
inline void
remove_edge_if(Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS) Graph;
typedef parallel::detail::remove_out_edge_predicate<Graph,
Predicate> Pred;
remove_edge_if(Pred(g, predicate), g.base());
}
namespace parallel { namespace detail {
/**
* Function object that applies the underlying predicate to
* determine if an undirected edge should be removed. If so,
* removes the local edges associated with the edge and
* (potentially) sends a message to the remote processor that also
* is removing this edge.
*/
template<typename Graph, typename Predicate>
struct remove_undirected_edge_predicate
{
typedef typename graph_traits<Graph>::edge_descriptor argument_type;
typedef bool result_type;
remove_undirected_edge_predicate(Graph& g, Predicate& predicate)
: g(g), predicate(predicate) { }
bool operator()(const argument_type& e)
{
if (predicate(e)) {
if (source(e, g).owner != target(e, g).owner)
g.send_remove_edge_request(e);
if (target(e, g).owner == g.processor())
::boost::detail::parallel::remove_in_edge(e, g, undirectedS());
if (source(e, g).owner == g.processor())
remove_edge(e.local, g.base());
return true;
} else return false;
}
private:
Graph& g;
Predicate predicate;
};
} } // end namespace parallel::detail
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG, typename Predicate>
inline void
remove_edge_if(Predicate predicate,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS) Graph;
typedef parallel::detail::remove_undirected_edge_predicate<Graph,
Predicate> Pred;
graph_detail::erase_if(g.local_edges(), Pred(g, predicate));
}
/************************************************************************
*
* clear_vertex
*
************************************************************************/
namespace parallel { namespace detail {
struct always_true
{
typedef bool result_type;
template<typename T> bool operator()(const T&) const { return true; }
};
} } // end namespace parallel::detail
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
void
clear_vertex
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
clear_out_edges(u, g);
clear_in_edges(u, g);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
void
clear_vertex
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)
::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(undirectedS)& g)
{
remove_out_edge_if(u, parallel::detail::always_true(), g);
}
/************************************************************************
*
* clear_out_edges
*
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
void
clear_out_edges
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)& g)
{
BOOST_ASSERT(u.owner == g.processor());
clear_out_edges(u.local, g.base());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
void
clear_out_edges
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
remove_out_edge_if(u, parallel::detail::always_true(), g);
}
/************************************************************************
*
* clear_in_edges
*
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS_CONFIG>
void
clear_in_edges
(typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)
::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(bidirectionalS)& g)
{
remove_in_edge_if(u, parallel::detail::always_true(), g);
}
/************************************************************************
*
* add_vertex
*
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor
add_vertex(PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE graph_type;
typename graph_type::vertex_property_type p;
return add_vertex(p, g);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename PBGL_DISTRIB_ADJLIST_TYPE::lazy_add_vertex_with_property
add_vertex(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_property_type const& p,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE
::lazy_add_vertex_with_property lazy_add_vertex;
return lazy_add_vertex(g, p);
}
/************************************************************************
*
* remove_vertex
*
************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
void
remove_vertex(typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor u,
PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename PBGL_DISTRIB_ADJLIST_TYPE::graph_type graph_type;
typedef typename graph_type::named_graph_mixin named_graph_mixin;
BOOST_ASSERT(u.owner == g.processor());
static_cast<named_graph_mixin&>(static_cast<graph_type&>(g))
.removing_vertex(u);
g.distribution().clear();
remove_vertex(u.local, g.base());
}
/***************************************************************************
* Implementation of Property Graph concept
***************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename Property>
struct property_map<PBGL_DISTRIB_ADJLIST_TYPE, Property>
: detail::parallel::get_adj_list_pmap<Property>
::template apply<PBGL_DISTRIB_ADJLIST_TYPE>
{ };
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename Property>
struct property_map<PBGL_DISTRIB_ADJLIST_TYPE const, Property>
: boost::detail::parallel::get_adj_list_pmap<Property>
// FIXME: in the original code the following was not const
::template apply<PBGL_DISTRIB_ADJLIST_TYPE const>
{ };
template<typename Property, PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, Property>::type
get(Property p, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE Graph;
typedef typename property_map<Graph, Property>::type result_type;
typedef typename property_traits<result_type>::value_type value_type;
typedef typename property_reduce<Property>::template apply<value_type>
reduce;
typedef typename property_traits<result_type>::key_type descriptor;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename mpl::if_<is_same<descriptor, vertex_descriptor>,
vertex_global_t, edge_global_t>::type
global_map_t;
return result_type(g.process_group(), get(global_map_t(), g),
get(p, g.base()), reduce());
}
template<typename Property, PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, Property>::const_type
get(Property p, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE Graph;
typedef typename property_map<Graph, Property>::const_type result_type;
typedef typename property_traits<result_type>::value_type value_type;
typedef typename property_reduce<Property>::template apply<value_type>
reduce;
typedef typename property_traits<result_type>::key_type descriptor;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename mpl::if_<is_same<descriptor, vertex_descriptor>,
vertex_global_t, edge_global_t>::type
global_map_t;
return result_type(g.process_group(), get(global_map_t(), g),
get(p, g.base()), reduce());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_local_index_t>::type
get(vertex_local_index_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
return get(vertex_local_index, g.base());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE,
vertex_local_index_t>::const_type
get(vertex_local_index_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
return get(vertex_local_index, g.base());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_global_t>::const_type
get(vertex_global_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_global_t>::const_type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_global_t>::const_type
get(vertex_global_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_global_t>::const_type result_type;
return result_type();
}
/// Retrieve a property map mapping from a vertex descriptor to its
/// owner.
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_owner_t>::type
get(vertex_owner_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_owner_t>::type result_type;
return result_type();
}
/// Retrieve a property map mapping from a vertex descriptor to its
/// owner.
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_owner_t>::const_type
get(vertex_owner_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_owner_t>::const_type result_type;
return result_type();
}
/// Retrieve the owner of a vertex
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline processor_id_type
get(vertex_owner_t, PBGL_DISTRIB_ADJLIST_TYPE&,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v)
{
return v.owner;
}
/// Retrieve the owner of a vertex
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline processor_id_type
get(vertex_owner_t, const PBGL_DISTRIB_ADJLIST_TYPE&,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v)
{
return v.owner;
}
/// Retrieve a property map that maps from a vertex descriptor to
/// its local descriptor.
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_local_t>::type
get(vertex_local_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_local_t>::type result_type;
return result_type();
}
/// Retrieve a property map that maps from a vertex descriptor to
/// its local descriptor.
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_local_t>::const_type
get(vertex_local_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
vertex_local_t>::const_type result_type;
return result_type();
}
/// Retrieve the local descriptor of a vertex
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline typename PBGL_DISTRIB_ADJLIST_TYPE::local_vertex_descriptor
get(vertex_local_t, PBGL_DISTRIB_ADJLIST_TYPE&,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v)
{
return v.local;
}
/// Retrieve the local descriptor of a vertex
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
inline typename PBGL_DISTRIB_ADJLIST_TYPE::local_vertex_descriptor
get(vertex_local_t, const PBGL_DISTRIB_ADJLIST_TYPE&,
typename PBGL_DISTRIB_ADJLIST_TYPE::vertex_descriptor v)
{
return v.local;
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_global_t>::const_type
get(edge_global_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_global_t>::const_type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_global_t>::const_type
get(edge_global_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_global_t>::const_type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_owner_t>::type
get(edge_owner_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_owner_t>::type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_owner_t>::const_type
get(edge_owner_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_owner_t>::const_type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_local_t>::type
get(edge_local_t, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_local_t>::type result_type;
return result_type();
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, edge_local_t>::const_type
get(edge_local_t, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE,
edge_local_t>::const_type result_type;
return result_type();
}
template<typename Property, PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS,
typename Key>
inline
typename property_traits<typename property_map<
PBGL_DISTRIB_ADJLIST_TYPE, Property>::const_type
>::value_type
get(Property p, const PBGL_DISTRIB_ADJLIST_TYPE& g, const Key& key)
{
if (owner(key) == process_id(g.process_group()))
return get(p, g.base(), local(key));
else
BOOST_ASSERT(false);
}
template<typename Property, PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS,
typename Key, typename Value>
void
put(Property p, PBGL_DISTRIB_ADJLIST_TYPE& g, const Key& key, const Value& v)
{
if (owner(key) == process_id(g.process_group()))
put(p, g.base(), local(key), v);
else
BOOST_ASSERT(false);
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_index_t>::type
get(vertex_index_t vi, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE graph_type;
typedef typename property_map<graph_type, vertex_index_t>::type
result_type;
return result_type(g.process_group(), get(vertex_global, g),
get(vi, g.base()));
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, vertex_index_t>::const_type
get(vertex_index_t vi, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE graph_type;
typedef typename property_map<graph_type, vertex_index_t>::const_type
result_type;
return result_type(g.process_group(), get(vertex_global, g),
get(vi, g.base()));
}
/***************************************************************************
* Implementation of bundled properties
***************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename T, typename Bundle>
struct property_map<PBGL_DISTRIB_ADJLIST_TYPE, T Bundle::*>
: detail::parallel::get_adj_list_pmap<T Bundle::*>
::template apply<PBGL_DISTRIB_ADJLIST_TYPE>
{ };
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename T, typename Bundle>
struct property_map<PBGL_DISTRIB_ADJLIST_TYPE const, T Bundle::*>
: detail::parallel::get_adj_list_pmap<T Bundle::*>
::template apply<PBGL_DISTRIB_ADJLIST_TYPE const>
{ };
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename T, typename Bundle>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, T Bundle::*>::type
get(T Bundle::* p, PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE Graph;
typedef typename property_map<Graph, T Bundle::*>::type result_type;
typedef typename property_traits<result_type>::value_type value_type;
typedef typename property_reduce<T Bundle::*>::template apply<value_type>
reduce;
typedef typename property_traits<result_type>::key_type descriptor;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename mpl::if_<is_same<descriptor, vertex_descriptor>,
vertex_global_t, edge_global_t>::type
global_map_t;
return result_type(g.process_group(), get(global_map_t(), g),
get(p, g.base()), reduce());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS, typename T, typename Bundle>
typename property_map<PBGL_DISTRIB_ADJLIST_TYPE, T Bundle::*>::const_type
get(T Bundle::* p, const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE Graph;
typedef typename property_map<Graph, T Bundle::*>::const_type result_type;
typedef typename property_traits<result_type>::value_type value_type;
typedef typename property_reduce<T Bundle::*>::template apply<value_type>
reduce;
typedef typename property_traits<result_type>::key_type descriptor;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename mpl::if_<is_same<descriptor, vertex_descriptor>,
vertex_global_t, edge_global_t>::type
global_map_t;
return result_type(g.process_group(), get(global_map_t(), g),
get(p, g.base()), reduce());
}
/***************************************************************************
* Implementation of DistributedGraph concept
***************************************************************************/
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
void synchronize(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{
typedef PBGL_DISTRIB_ADJLIST_TYPE graph_type;
synchronize(g.process_group());
}
template<PBGL_DISTRIB_ADJLIST_TEMPLATE_PARMS>
ProcessGroup
process_group(const PBGL_DISTRIB_ADJLIST_TYPE& g)
{ return g.process_group(); }
/***************************************************************************
* Specializations of is_mpi_datatype for Serializable entities
***************************************************************************/
namespace mpi {
template<typename Directed, typename Vertex>
struct is_mpi_datatype<boost::detail::edge_base<Directed, Vertex> >
: is_mpi_datatype<Vertex> { };
template<typename Directed, typename Vertex>
struct is_mpi_datatype<boost::detail::edge_desc_impl<Directed, Vertex> >
: is_mpi_datatype<boost::detail::edge_base<Directed, Vertex> > { };
template<typename LocalDescriptor>
struct is_mpi_datatype<boost::detail::parallel::global_descriptor<LocalDescriptor> >
: is_mpi_datatype<LocalDescriptor> { };
template<typename Edge>
struct is_mpi_datatype<boost::detail::parallel::edge_descriptor<Edge> >
: is_mpi_datatype<Edge> { };
template<typename Vertex, typename LocalVertex>
struct is_mpi_datatype<boost::detail::parallel::
msg_add_edge_data<Vertex, LocalVertex> >
: is_mpi_datatype<Vertex> { };
template<typename Vertex, typename LocalVertex, typename EdgeProperty>
struct is_mpi_datatype<boost::detail::parallel::
msg_add_edge_with_property_data<Vertex,
LocalVertex,
EdgeProperty> >
: mpl::and_<is_mpi_datatype<Vertex>, is_mpi_datatype<EdgeProperty> > { };
template<typename EdgeProperty, typename EdgeDescriptor>
struct is_mpi_datatype<boost::detail::parallel::msg_nonlocal_edge_data<
EdgeProperty,EdgeDescriptor> >
: mpl::and_<
is_mpi_datatype<boost::detail::parallel::maybe_store_property<
EdgeProperty> >,
is_mpi_datatype<EdgeDescriptor> >
{};
template<typename EdgeDescriptor>
struct is_mpi_datatype<
boost::detail::parallel::msg_remove_edge_data<EdgeDescriptor> >
: is_mpi_datatype<EdgeDescriptor> {};
}
/***************************************************************************
* Specializations of is_bitwise_serializable for Serializable entities
***************************************************************************/
namespace serialization {
template<typename Directed, typename Vertex>
struct is_bitwise_serializable<boost::detail::edge_base<Directed, Vertex> >
: is_bitwise_serializable<Vertex> { };
template<typename Directed, typename Vertex>
struct is_bitwise_serializable<boost::detail::edge_desc_impl<Directed, Vertex> >
: is_bitwise_serializable<boost::detail::edge_base<Directed, Vertex> > { };
template<typename LocalDescriptor>
struct is_bitwise_serializable<boost::detail::parallel::global_descriptor<LocalDescriptor> >
: is_bitwise_serializable<LocalDescriptor> { };
template<typename Edge>
struct is_bitwise_serializable<boost::detail::parallel::edge_descriptor<Edge> >
: is_bitwise_serializable<Edge> { };
template<typename Vertex, typename LocalVertex>
struct is_bitwise_serializable<boost::detail::parallel::
msg_add_edge_data<Vertex, LocalVertex> >
: is_bitwise_serializable<Vertex> { };
template<typename Vertex, typename LocalVertex, typename EdgeProperty>
struct is_bitwise_serializable<boost::detail::parallel::
msg_add_edge_with_property_data<Vertex,
LocalVertex,
EdgeProperty> >
: mpl::and_<is_bitwise_serializable<Vertex>,
is_bitwise_serializable<EdgeProperty> > { };
template<typename EdgeProperty, typename EdgeDescriptor>
struct is_bitwise_serializable<boost::detail::parallel::msg_nonlocal_edge_data<
EdgeProperty,EdgeDescriptor> >
: mpl::and_<
is_bitwise_serializable<
boost::detail::parallel::maybe_store_property<EdgeProperty> >,
is_bitwise_serializable<EdgeDescriptor> >
{};
template<typename EdgeDescriptor>
struct is_bitwise_serializable<
boost::detail::parallel::msg_remove_edge_data<EdgeDescriptor> >
: is_bitwise_serializable<EdgeDescriptor> {};
template<typename Directed, typename Vertex>
struct implementation_level<boost::detail::edge_base<Directed, Vertex> >
: mpl::int_<object_serializable> {};
template<typename Directed, typename Vertex>
struct implementation_level<boost::detail::edge_desc_impl<Directed, Vertex> >
: mpl::int_<object_serializable> {};
template<typename LocalDescriptor>
struct implementation_level<boost::detail::parallel::global_descriptor<LocalDescriptor> >
: mpl::int_<object_serializable> {};
template<typename Edge>
struct implementation_level<boost::detail::parallel::edge_descriptor<Edge> >
: mpl::int_<object_serializable> {};
template<typename Vertex, typename LocalVertex>
struct implementation_level<boost::detail::parallel::
msg_add_edge_data<Vertex, LocalVertex> >
: mpl::int_<object_serializable> {};
template<typename Vertex, typename LocalVertex, typename EdgeProperty>
struct implementation_level<boost::detail::parallel::
msg_add_edge_with_property_data<Vertex,
LocalVertex,
EdgeProperty> >
: mpl::int_<object_serializable> {};
template<typename EdgeProperty, typename EdgeDescriptor>
struct implementation_level<boost::detail::parallel::msg_nonlocal_edge_data<
EdgeProperty,EdgeDescriptor> >
: mpl::int_<object_serializable> {};
template<typename EdgeDescriptor>
struct implementation_level<
boost::detail::parallel::msg_remove_edge_data<EdgeDescriptor> >
: mpl::int_<object_serializable> {};
template<typename Directed, typename Vertex>
struct tracking_level<boost::detail::edge_base<Directed, Vertex> >
: mpl::int_<track_never> {};
template<typename Directed, typename Vertex>
struct tracking_level<boost::detail::edge_desc_impl<Directed, Vertex> >
: mpl::int_<track_never> {};
template<typename LocalDescriptor>
struct tracking_level<boost::detail::parallel::global_descriptor<LocalDescriptor> >
: mpl::int_<track_never> {};
template<typename Edge>
struct tracking_level<boost::detail::parallel::edge_descriptor<Edge> >
: mpl::int_<track_never> {};
template<typename Vertex, typename LocalVertex>
struct tracking_level<boost::detail::parallel::
msg_add_edge_data<Vertex, LocalVertex> >
: mpl::int_<track_never> {};
template<typename Vertex, typename LocalVertex, typename EdgeProperty>
struct tracking_level<boost::detail::parallel::
msg_add_edge_with_property_data<Vertex,
LocalVertex,
EdgeProperty> >
: mpl::int_<track_never> {};
template<typename EdgeProperty, typename EdgeDescriptor>
struct tracking_level<boost::detail::parallel::msg_nonlocal_edge_data<
EdgeProperty,EdgeDescriptor> >
: mpl::int_<track_never> {};
template<typename EdgeDescriptor>
struct tracking_level<
boost::detail::parallel::msg_remove_edge_data<EdgeDescriptor> >
: mpl::int_<track_never> {};
}
// Hash function for global descriptors
template<typename LocalDescriptor>
struct hash<detail::parallel::global_descriptor<LocalDescriptor> >
{
typedef detail::parallel::global_descriptor<LocalDescriptor> argument_type;
std::size_t operator()(argument_type const& x) const
{
std::size_t hash = hash_value(x.owner);
hash_combine(hash, x.local);
return hash;
}
};
// Hash function for parallel edge descriptors
template<typename Edge>
struct hash<detail::parallel::edge_descriptor<Edge> >
{
typedef detail::parallel::edge_descriptor<Edge> argument_type;
std::size_t operator()(argument_type const& x) const
{
std::size_t hash = hash_value(x.owner());
hash_combine(hash, x.local);
return hash;
}
};
} // end namespace boost
#include <boost/graph/distributed/adjlist/handlers.hpp>
#include <boost/graph/distributed/adjlist/initialize.hpp>
#include <boost/graph/distributed/adjlist/redistribute.hpp>
#include <boost/graph/distributed/adjlist/serialization.hpp>
#endif // BOOST_GRAPH_DISTRIBUTED_ADJACENCY_LIST_HPP