gko::experimental::distributed::
index_map#

Translates between global indices and the local indices each rank uses to refer to its local and non-local data. Holds the compressed list of remote columns referenced by the rank’s non-local block, plus the local-to-global lookup needed during halo exchanges.

template<typename LocalIndexType, typename GlobalIndexType = int64>
class index_map#

This class defines mappings between global and local indices.

Given an index space $I = [0, \dots, N)$ that is partitioned into $P$ disjoint subsets $I_k, k = 1, \dots, P$, this class defines for each subset an extended global index set $\hat{I}_k \supset I_K$. The extended index set contains the global indices owned by part $k$, as well as remote indices $R_k = \hat{I}_k \setminus I_k$, which are also accessed by part $k$, but owned by parts $l \neq k$. At the core, this class provides mappings from the global index space $I$ into different local index spaces. The combined local index space (index_space::combined) is then defined as $[0, \dots, |\hat{I}_k|)$. Additionally, the combined index space can be separated into locally owned (index_space::local) and non-locally owned (index_space::non_local). The locally owned indices are defined as $[0, \dots, |I_k|)$, and the non-locally owned as $[0, \dots, |R_k|)$. With these index sets, the following mappings are defined:

  • $c_k : \hat{I}_k \mapsto [0, \dots, |\hat{I}_k|)$ which maps global indices into the combined/full local index space (denoted as index_space::combined),

  • $l_k: I_k \mapsto [0, \dots, |I_k|)$ which maps global indices into the locally owned index space (denoted as index_space::local),

  • $r_k: R_k \mapsto [0, \dots, |R_k|)$ which maps global indices into the non-locally owned index space (denoted as index_space::non_local).

The required map can be selected by passing the appropriate type of an index_space.

The index map for $I_k$ has no knowledge about any other index maps for $I_l, l \neq k$. In particular, any global index passed to the map_to_local map that is not part of the specified index space, will be mapped to an invalid_index.

Template Parameters:

  • LocalIndexType – type for local indices

  • GlobalIndexType – type for global indices

Public Functions

array<LocalIndexType> map_to_local(
const array<GlobalIndexType> &global_ids,
index_space index_space_v,
) const#

Maps global indices to local indices.

Parameters:

  • global_ids – the global indices to map

  • index_space_v – the index space in which the returned local indices are defined

Returns:

the mapped local indices. Any global index that is not in the specified index space is mapped to invalid_index.

array<GlobalIndexType> map_to_global(
const array<LocalIndexType> &local_idxs,
index_space index_space_v,
) const#

Maps local indices to global indices

Parameters:

  • local_idxs – the local indices to map

  • index_space_v – the index space in which the passed-in local indices are defined

Returns:

the mapped global indices. Any local index that is not in the specified index space is mapped to invalid_index

size_type get_global_size() const#

get size of the global index space

size_type get_local_size() const#

get size of index_space::local

size_type get_non_local_size() const#

get size of index_space::non_local

index_map(
std::shared_ptr<const Executor> exec,
std::shared_ptr<const partition_type> partition,
comm_index_type rank,
const array<GlobalIndexType> &recv_connections,
)#

Creates a new index map.

The passed in recv_connections may contain duplicates, which will be filtered out.

Parameters:

  • exec – the executor

  • partition – the partition of the global index set

  • rank – the id of the global index space subset

  • recv_connections – the global indices that are not owned by this rank, but accessed by it

index_map(std::shared_ptr<const Executor> exec)#

Creates an empty index map.

const segmented_array<GlobalIndexType> &get_remote_global_idxs(
) const#

get the index set $R_k$ for this rank.

The indices are ordered by their owning rank and global index.

const segmented_array<LocalIndexType> &get_remote_local_idxs(
) const#

get the index set $R_k$, but mapped to their respective local index space.

The indices are grouped by their owning rank and sorted according to their global index within each group.

The set $R_k = \hat{I}_k \setminus I_k$ can also be written as the union of the intersection of $\hat{I}_k$ with other disjoint sets $I_l, l \neq k$, i.e. $R_k = \bigcup_{j \neq k} \hat{I}_k \cap I_j = \bigcup_{j \neq k} R_{k,j}$. The set $R_{k,j}$ can then be mapped by $l_j$ to get the local indices wrt. part $j$. The indices here are mapped by $l_j$.

const array<comm_index_type> &get_remote_target_ids() const#

get the rank ids which contain indices accessed by this rank.

The order matches the order of the sets in get_remote_global_idxs and get_remote_local_idxs.

std::shared_ptr<const Executor> get_executor() const#

get the associated executor.