/Src/Dependencies/Boost/boost/graph/distributed/adjacency_list.hpp
C++ Header | 3970 lines | 2664 code | 533 blank | 773 comment | 189 complexity | 3c4b75ee66cb03622c873a03e54057c9 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-2.0, Apache-2.0, LGPL-3.0
- // 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);
- exit(1);
- }
- }
- #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