745 lines
27 KiB
ReStructuredText
745 lines
27 KiB
ReStructuredText
.. Copyright (C) 2004-2008 The Trustees of Indiana University.
|
|
Use, modification and distribution is subject to the Boost Software
|
|
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
|
http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
===============================
|
|
|Logo| Distributed Property Map
|
|
===============================
|
|
|
|
A distributed property map adaptor is a property map whose stored
|
|
values are distributed across multiple non-overlapping memory spaces
|
|
on different processes. Values local to the current process are stored
|
|
within a local property map and may be immediately accessed via
|
|
``get`` and ``put``. Values stored on remote processes may also be
|
|
accessed via ``get`` and ``put``, but the behavior differs slightly:
|
|
|
|
- ``put`` operations update a local ghost cell and send a "put"
|
|
message to the process that owns the value. The owner is free to
|
|
update its own "official" value or may ignore the put request.
|
|
|
|
- ``get`` operations returns the contents of the local ghost
|
|
cell. If no ghost cell is available, one is created using a
|
|
(customizable) default value.
|
|
|
|
Using distributed property maps requires a bit more care than using
|
|
local, sequential property maps. While the syntax and semantics are
|
|
similar, distributed property maps may contain out-of-date
|
|
information that can only be guaranteed to be synchronized by
|
|
calling the ``synchronize`` function in all processes.
|
|
|
|
To address the issue of out-of-date values, distributed property
|
|
maps support multiple `consistency models`_ and may be supplied with a
|
|
`reduction operation`_.
|
|
|
|
Distributed property maps meet the requirements of the `Readable
|
|
Property Map`_ and, potentially, the `Writable Property Map`_ and
|
|
`Read/Write Property Map`_ concepts. Distributed property maps do
|
|
*not*, however, meet the requirements of the `Lvalue Property Map`_
|
|
concept, because elements residing in another process are not
|
|
directly addressible. There are several forms of distributed property
|
|
maps:
|
|
|
|
- `Distributed property map adaptor`_
|
|
- `Distributed iterator property map`_
|
|
- `Distributed safe iterator property map`_
|
|
- `Local property map`_
|
|
|
|
------------------
|
|
Consistency models
|
|
------------------
|
|
|
|
Distributed property maps offer many consistency models, which affect
|
|
how the values read from and written to remote keys relate to the
|
|
"official" value for that key stored in the owning process. The
|
|
consistency model of a distributed property map can be set with the
|
|
member function ``set_consistency_model`` to a bitwise-OR of the
|
|
flags in the ``boost::parallel::consistency_model`` enumeration. The
|
|
individual flags are:
|
|
|
|
- ``cm_forward``: The default consistency model, which propagates
|
|
values forward from ``put`` operations on remote processors to
|
|
the owner of the value being changed.
|
|
|
|
- ``cm_backward``: After all values have been forwarded or flushed
|
|
to the owning processes, each process receives updates values for
|
|
each of its ghost cells. After synchronization, the values in
|
|
ghost cells are guaranteed to match the values stored on the
|
|
owning processor.
|
|
|
|
- ``cm_bidirectional``: A combination of both ``cm_forward`` and
|
|
``cm_backward``.
|
|
|
|
- ``cm_flush``: At the beginning of synchronization, all of the
|
|
values stored locally in ghost cells are sent to their owning
|
|
processors.
|
|
|
|
- ``cm_reset``: Executes a ``reset()`` operation after
|
|
synchronization, setting the values in each ghost cell to their
|
|
default value.
|
|
|
|
- ``cm_clear``: Executes a ``clear()`` operation after
|
|
synchronizing, eliminating all ghost cells.
|
|
|
|
|
|
There are several common combinations of flags that result in
|
|
interesting consistency models. Some of these combinations are:
|
|
|
|
- ``cm_forward``: By itself, the forward consistency model enables
|
|
algorithms such as `Dijkstra's shortest paths`_ and
|
|
`Breadth-First Search`_ to operate correctly.
|
|
|
|
- ``cm_flush & cm_reset``: All updates values are queued locally,
|
|
then flushed during the synchronization step. Once the flush has
|
|
occurred, the ghost cells are restored to their default
|
|
values. This consistency model is used by the PageRank_
|
|
implementation to locally accumulate rank for each node.
|
|
|
|
|
|
-------------------
|
|
Reduction operation
|
|
-------------------
|
|
|
|
The reduction operation maintains consistency by determining how
|
|
multiple writes to a property map are resolved and what the property
|
|
map should do if unknown values are requested. More specifically, a
|
|
reduction operation is used in two cases:
|
|
|
|
1. When a value is needed for a remote key but no value is
|
|
immediately available, the reduction operation provides a
|
|
suitable default. For instance, a distributed property map
|
|
storing distances may have a reduction operation that returns
|
|
an infinite value as the default, whereas a distributed
|
|
property map for vertex colors may return white as the
|
|
default.
|
|
|
|
2. When a value is received from a remote process, the process
|
|
owning the key associated with that value must determine which
|
|
value---the locally stored value, the value received from a
|
|
remote process, or some combination of the two---will be
|
|
stored as the "official" value in the property map. The
|
|
reduction operation transforms the local and remote values
|
|
into the "official" value to be stored.
|
|
|
|
The reduction operation of a distributed property map can be set with
|
|
the ``set_reduce`` method of ``distributed_property_map``. The reduce
|
|
operation is a function object with two signatures. The first
|
|
signature takes a (remote) key and returns a default value for it,
|
|
whereas the second signatures takes a key and two values (local first,
|
|
then remote) and will return the combined value that will be stored in
|
|
the local property map. Reduction operations must also contain a
|
|
static constant ``non_default_resolver", which states whether the
|
|
reduction operation's default value actually acts like a default
|
|
value. It should be ``true`` when the default is meaningful (e.g.,
|
|
infinity for a distance) and ``false`` when the default should not be
|
|
used.
|
|
|
|
The following reduction operation is used by the distributed PageRank
|
|
algorithm. The default rank for a remote node is 0. Rank is
|
|
accumulated locally, and then the reduction operation combines local
|
|
and remote values by adding them. Combined with a consistency model
|
|
that flushes all values to the owner and then resets the values
|
|
locally in each step, the resulting property map will compute partial
|
|
sums on each processor and then accumulate the results on the owning
|
|
processor. The PageRank reduction operation is defined as follows.
|
|
|
|
::
|
|
|
|
template<typename T>
|
|
struct rank_accumulate_reducer {
|
|
static const bool non_default_resolver = true;
|
|
|
|
// The default rank of an unknown node
|
|
template<typename K>
|
|
T operator()(const K&) const { return T(0); }
|
|
|
|
template<typename K>
|
|
T operator()(const K&, const T& x, const T& y) const { return x + y; }
|
|
};
|
|
|
|
|
|
--------------------------------
|
|
Distributed property map adaptor
|
|
--------------------------------
|
|
|
|
The distributed property map adaptor creates a distributed property
|
|
map from a local property map, a `process group`_ over which
|
|
distribution should occur, and a `global descriptor`_ type that
|
|
indexes the distributed property map.
|
|
|
|
|
|
Synopsis
|
|
~~~~~~~~
|
|
|
|
::
|
|
|
|
template<typename ProcessGroup, typename LocalPropertyMap, typename Key,
|
|
typename GhostCellS = gc_mapS>
|
|
class distributed_property_map
|
|
{
|
|
public:
|
|
typedef ... ghost_regions_type;
|
|
|
|
distributed_property_map();
|
|
|
|
distributed_property_map(const ProcessGroup& pg,
|
|
const LocalPropertyMap& pm);
|
|
|
|
template<typename Reduce>
|
|
distributed_property_map(const ProcessGroup& pg,
|
|
const LocalPropertyMap& pm,
|
|
const Reduce& reduce);
|
|
|
|
template<typename Reduce> void set_reduce(const Reduce& reduce);
|
|
void set_consistency_model(int model);
|
|
|
|
void flush();
|
|
void reset();
|
|
void clear();
|
|
};
|
|
|
|
reference get(distributed_property_map pm, const key_type& key);
|
|
|
|
void
|
|
put(distributed_property_map pm, const key_type& key, const value_type& value);
|
|
local_put(distributed_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
void request(distributed_property_map pm, const key_type& key);
|
|
|
|
void synchronize(distributed_property_map& pm);
|
|
|
|
template<typename Key, typename ProcessGroup, typename LocalPropertyMap>
|
|
distributed_property_map<ProcessGroup, LocalPropertyMap, Key>
|
|
make_distributed_property_map(const ProcessGroup& pg, LocalPropertyMap pmap);
|
|
|
|
template<typename Key, typename ProcessGroup, typename LocalPropertyMap,
|
|
typename Reduce>
|
|
distributed_property_map<ProcessGroup, LocalPropertyMap, Key>
|
|
make_distributed_property_map(const ProcessGroup& pg, LocalPropertyMap pmap,
|
|
Reduce reduce);
|
|
|
|
Template parameters
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
**ProcessGroup**:
|
|
The type of the process group over which the
|
|
property map is distributed and is also the medium for
|
|
communication.
|
|
|
|
|
|
**LocalPropertyMap**:
|
|
The type of the property map that will store values
|
|
for keys local to this processor. The ``value_type`` of this
|
|
property map will become the ``value_type`` of the distributed
|
|
property map. The distributed property map models the same property
|
|
map concepts as the ``LocalPropertyMap``, with one exception: a
|
|
distributed property map cannot be an `Lvalue Property Map`_
|
|
(because remote values are not addressable), and is therefore
|
|
limited to `Read/Write Property Map`_.
|
|
|
|
|
|
**Key**:
|
|
The ``key_type`` of the distributed property map, which
|
|
must model the `Global Descriptor`_ concept. The process ID type of
|
|
the ``Key`` parameter must match the process ID type of the
|
|
``ProcessGroup``, and the local descriptor type of the ``Key`` must
|
|
be convertible to the ``key_type`` of the ``LocalPropertyMap``.
|
|
|
|
|
|
**GhostCellS**:
|
|
A selector type that indicates how ghost cells should be stored in
|
|
the distributed property map. There are either two or three
|
|
options, depending on your compiler:
|
|
|
|
- ``boost::parallel::gc_mapS`` (default): Uses an STL ``map`` to
|
|
store the ghost cells for each process.
|
|
|
|
- ``boost::parallel::gc_vector_mapS``: Uses a sorted STL
|
|
``vector`` to store the ghost cells for each process. This
|
|
option works well when there are likely to be few insertions
|
|
into the ghost cells; for instance, if the only ghost cells used
|
|
are for neighboring vertices, the property map can be
|
|
initialized with cells for each neighboring vertex, providing
|
|
faster lookups than a ``map`` and using less space.
|
|
|
|
- ``boost::parallel::gc_hash_mapS``: Uses the GCC ``hash_map`` to
|
|
store ghost cells. This option may improve performance over
|
|
``map`` for large problems sizes, where the set of ghost cells
|
|
cannot be predetermined.
|
|
|
|
|
|
Member functions
|
|
~~~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
distributed_property_map();
|
|
|
|
Default-construct a distributed property map. The property map is in
|
|
an invalid state, and may only be used if it is reassigned to a valid
|
|
property map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
distributed_property_map(const ProcessGroup& pg,
|
|
const LocalPropertyMap& pm);
|
|
|
|
template<typename Reduce>
|
|
distributed_property_map(const ProcessGroup& pg,
|
|
const LocalPropertyMap& pm,
|
|
const Reduce& reduce);
|
|
|
|
Construct a property map from a process group and a local property
|
|
map. If a ``reduce`` operation is not supplied, a default of
|
|
``basic_reduce<value_type>`` will be used.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
template<typename Reduce> void set_reduce(const Reduce& reduce);
|
|
|
|
Replace the current reduction operation with the new operation
|
|
``reduce``.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void set_consistency_model(int model);
|
|
|
|
Sets the consistency model of the distributed property map, which will
|
|
take effect on the next synchronization step. See the section
|
|
`Consistency models`_ for a description of the effect of various
|
|
consistency model flags.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void flush();
|
|
|
|
Emits a message sending the contents of all local ghost cells to the
|
|
owners of those cells.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void reset();
|
|
|
|
Replaces the values stored in each of the ghost cells with the default
|
|
value generated by the reduction operation.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void clear();
|
|
|
|
Removes all ghost cells from the property map.
|
|
|
|
|
|
Free functions
|
|
~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
reference get(distributed_property_map pm, const key_type& key);
|
|
|
|
Retrieves the element in ``pm`` associated with the given ``key``. If
|
|
the key refers to data stored locally, returns the actual value
|
|
associated with the key. If the key refers to nonlocal data, returns
|
|
the value of the ghost cell. If no ghost cell exists, the behavior
|
|
depends on the current reduction operation: if a reduction operation
|
|
has been set and has ``non_default_resolver`` set ``true``, then a
|
|
ghost cell will be created according to the default value provided by
|
|
the reduction operation. Otherwise, the call to ``get`` will abort
|
|
because no value exists for this remote cell. To avoid this problem,
|
|
either set a reduction operation that generates default values,
|
|
``request()`` the value and then perform a synchronization step, or
|
|
``put`` a value into the cell before reading it.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void
|
|
put(distributed_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Places the given ``value`` associated with ``key`` into property map
|
|
``pm``. If the key refers to data stored locally, the value is
|
|
immediately updates. If the key refers to data stored in a remote
|
|
process, updates (or creates) a local ghost cell containing this
|
|
value for the key and sends the new value to the owning process. Note
|
|
that the owning process may reject this value based on the reduction
|
|
operation, but this will not be detected until the next
|
|
synchronization step.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void
|
|
local_put(distributed_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Equivalent to ``put(pm, key, value)``, except that no message is sent
|
|
to the owning process when the value is changed for a nonlocal key.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void synchronize(distributed_property_map& pm);
|
|
|
|
Synchronize the values stored in the distributed property maps. Each
|
|
process much execute ``synchronize`` at the same time, after which
|
|
the ghost cells in every process will reflect the actual value stored
|
|
in the owning process.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void request(distributed_property_map pm, const key_type& key);
|
|
|
|
Request that the element "key" be available after the next
|
|
synchronization step. For a non-local key, this means establishing a
|
|
ghost cell and requesting.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
template<typename Key, typename ProcessGroup, typename LocalPropertyMap>
|
|
distributed_property_map<ProcessGroup, LocalPropertyMap, Key>
|
|
make_distributed_property_map(const ProcessGroup& pg, LocalPropertyMap pmap);
|
|
|
|
template<typename Key, typename ProcessGroup, typename LocalPropertyMap,
|
|
typename Reduce>
|
|
distributed_property_map<ProcessGroup, LocalPropertyMap, Key>
|
|
make_distributed_property_map(const ProcessGroup& pg, LocalPropertyMap pmap,
|
|
Reduce reduce);
|
|
|
|
Create a distributed property map over process group ``pg`` and local
|
|
property map ``pmap``. A default reduction operation will be generated
|
|
if it is not provided.
|
|
|
|
---------------------------------
|
|
Distributed iterator property map
|
|
---------------------------------
|
|
|
|
The distributed iterator property map adaptor permits the creation of
|
|
distributed property maps from random access iterators using the same
|
|
syntax as non-distributed iterator property maps. The specialization
|
|
is based on a `local property map`_, which contains the
|
|
indices for local descriptors and is typically returned to describe
|
|
the vertex indices of a distributed graph.
|
|
|
|
Synopsis
|
|
~~~~~~~~
|
|
|
|
::
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap, typename ValueType,
|
|
typename Reference>
|
|
class iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference>
|
|
{
|
|
public:
|
|
typedef local_property_map<ProcessGroup, GlobalKey, LocalMap> index_map_type;
|
|
|
|
iterator_property_map();
|
|
iterator_property_map(RandomAccessIterator iter, const index_map_type& id);
|
|
};
|
|
|
|
reference get(iterator_property_map pm, const key_type& key);
|
|
void put(iterator_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap>
|
|
iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap> >
|
|
make_iterator_property_map(RandomAccessIterator iter,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap> id);
|
|
|
|
|
|
Member functions
|
|
~~~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
iterator_property_map();
|
|
|
|
Default-constructs a distributed iterator property map. The property
|
|
map is in an invalid state, and must be reassigned before it may be
|
|
used.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
iterator_property_map(RandomAccessIterator iter, const index_map_type& id);
|
|
|
|
Constructs a distributed iterator property map using the property map
|
|
``id`` to map global descriptors to local indices. The random access
|
|
iterator sequence ``[iter, iter + n)`` must be a valid range, where
|
|
``[0, n)`` is the range of local indices.
|
|
|
|
Free functions
|
|
~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
reference get(iterator_property_map pm, const key_type& key);
|
|
|
|
Returns the value associated with the given ``key`` from the
|
|
distributed property map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void put(iterator_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Associates the value with the given key in the distributed property map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap, typename ValueType,
|
|
typename Reference>
|
|
iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference>
|
|
make_iterator_property_map(RandomAccessIterator iter,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference> id);
|
|
|
|
Creates a distributed iterator property map using the given iterator
|
|
``iter`` and local index property map ``id``.
|
|
|
|
--------------------------------------
|
|
Distributed safe iterator property map
|
|
--------------------------------------
|
|
|
|
The distributed safe iterator property map adaptor permits the
|
|
creation of distributed property maps from random access iterators
|
|
using the same syntax as non-distributed safe iterator property
|
|
maps. The specialization is based on a `local property map`_, which
|
|
contains the indices for local descriptors and is typically returned
|
|
to describe the vertex indices of a distributed graph. Safe iterator
|
|
property maps check the indices of accesses to ensure that they are
|
|
not out-of-bounds before attempting to access an value.
|
|
|
|
Synopsis
|
|
~~~~~~~~
|
|
|
|
::
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap, typename ValueType,
|
|
typename Reference>
|
|
class safe_iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference>
|
|
{
|
|
public:
|
|
typedef local_property_map<ProcessGroup, GlobalKey, LocalMap> index_map_type;
|
|
|
|
safe_iterator_property_map();
|
|
safe_iterator_property_map(RandomAccessIterator iter, std::size_t n,
|
|
const index_map_type& id);
|
|
};
|
|
|
|
reference get(safe_iterator_property_map pm, const key_type& key);
|
|
void put(safe_iterator_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap, typename ValueType,
|
|
typename Reference>
|
|
safe_iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference>
|
|
make_safe_iterator_property_map(RandomAccessIterator iter,
|
|
std::size_t n,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference> id);
|
|
|
|
Member functions
|
|
~~~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
safe_iterator_property_map();
|
|
|
|
Default-constructs a distributed safe iterator property map. The property
|
|
map is in an invalid state, and must be reassigned before it may be
|
|
used.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
safe_iterator_property_map(RandomAccessIterator iter, std::size_t n,
|
|
const index_map_type& id);
|
|
|
|
Constructs a distributed safe iterator property map using the property map
|
|
``id`` to map global descriptors to local indices. The random access
|
|
iterator sequence ``[iter, iter + n)``.
|
|
|
|
Free functions
|
|
~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
reference get(safe_iterator_property_map pm, const key_type& key);
|
|
|
|
Returns the value associated with the given ``key`` from the
|
|
distributed property map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void put(safe_iterator_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Associates the value with the given key in the distributed property map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
template<typename RandomAccessIterator, typename ProcessGroup,
|
|
typename GlobalKey, typename LocalMap, typename ValueType,
|
|
typename Reference>
|
|
safe_iterator_property_map<RandomAccessIterator,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference>
|
|
make_safe_iterator_property_map(RandomAccessIterator iter,
|
|
std::size_t n,
|
|
local_property_map<ProcessGroup, GlobalKey, LocalMap>,
|
|
ValueType, Reference> id);
|
|
|
|
Creates a distributed safe iterator property map using the given iterator
|
|
``iter`` and local index property map ``id``. The indices in ``id`` must
|
|
|
|
------------------
|
|
Local property map
|
|
------------------
|
|
|
|
A property map adaptor that accesses an underlying property map whose
|
|
key type is the local part of the ``Key`` type for the local subset
|
|
of keys. Local property maps are typically used by distributed graph
|
|
types for vertex index properties.
|
|
|
|
Synopsis
|
|
~~~~~~~~
|
|
|
|
::
|
|
|
|
template<typename ProcessGroup, typename GlobalKey, typename LocalMap>
|
|
class local_property_map
|
|
{
|
|
public:
|
|
typedef typename property_traits<LocalMap>::value_type value_type;
|
|
typedef GlobalKey key_type;
|
|
typedef typename property_traits<LocalMap>::reference reference;
|
|
typedef typename property_traits<LocalMap>::category category;
|
|
|
|
explicit
|
|
local_property_map(const ProcessGroup& process_group = ProcessGroup(),
|
|
const LocalMap& local_map = LocalMap());
|
|
|
|
reference operator[](const key_type& key);
|
|
};
|
|
|
|
reference get(const local_property_map& pm, key_type key);
|
|
void put(local_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Template parameters
|
|
~~~~~~~~~~~~~~~~~~~
|
|
|
|
:ProcessGroup: the type of the process group over which the global
|
|
keys are distributed.
|
|
|
|
:GlobalKey: The ``key_type`` of the local property map, which
|
|
must model the `Global Descriptor`_ concept. The process ID type of
|
|
the ``GlobalKey`` parameter must match the process ID type of the
|
|
``ProcessGroup``, and the local descriptor type of the ``GlobalKey``
|
|
must be convertible to the ``key_type`` of the ``LocalMap``.
|
|
|
|
:LocalMap: the type of the property map that will store values
|
|
for keys local to this processor. The ``value_type`` of this
|
|
property map will become the ``value_type`` of the local
|
|
property map. The local property map models the same property
|
|
map concepts as the ``LocalMap``.
|
|
|
|
Member functions
|
|
~~~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
explicit
|
|
local_property_map(const ProcessGroup& process_group = ProcessGroup(),
|
|
const LocalMap& local_map = LocalMap());
|
|
|
|
Constructs a local property map whose keys are distributed across the
|
|
given process group and which accesses the given local map.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
reference operator[](const key_type& key);
|
|
|
|
Access the value associated with the given key, which must be local
|
|
to this process.
|
|
|
|
Free functions
|
|
~~~~~~~~~~~~~~
|
|
|
|
::
|
|
|
|
reference get(const local_property_map& pm, key_type key);
|
|
|
|
Return the value associated with the given key, which must be local
|
|
to this process.
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
::
|
|
|
|
void put(local_property_map pm, const key_type& key, const value_type& value);
|
|
|
|
Set the value associated with the given key, which must be local to
|
|
this process.
|
|
|
|
-----------------------------------------------------------------------------
|
|
|
|
Copyright (C) 2004, 2005 The Trustees of Indiana University.
|
|
|
|
Authors: Douglas Gregor and Andrew Lumsdaine
|
|
|
|
.. |Logo| image:: pbgl-logo.png
|
|
:align: middle
|
|
:alt: Parallel BGL
|
|
:target: http://www.osl.iu.edu/research/pbgl
|
|
|
|
.. _Readable Property Map: http://www.boost.org/libs/property_map/ReadablePropertyMap.html
|
|
.. _Writable Property Map: http://www.boost.org/libs/property_map/WritablePropertyMap.html
|
|
.. _Read/Write Property Map: http://www.boost.org/libs/property_map/ReadWritePropertyMap.html
|
|
.. _Lvalue Property Map: http://www.boost.org/libs/property_map/LvaluePropertyMap.html
|
|
.. _Process Group: process_group.html
|
|
.. _Global Descriptor: GlobalDescriptor.html
|
|
.. _Dijkstra's shortest paths: dijkstra_shortest_paths.html
|
|
.. _Breadth-First Search: breadth_first_search.html
|
|
.. _PageRank: page_rank.html
|
|
|