template<typename T, HandleEnum E, typename IndexT>
vt::rdma::SubHandle struct

Public types

using HandleType = Handle<T, vt::rdma::HandleEnum::StaticSize, IndexT>
using ProxyType = vt::objgroup::proxy::Proxy<SubHandle<T, E, IndexT>>

Public static functions

static void destroyCollective(ProxyType proxy)
template<mapping::ActiveMapTypedFnType<IndexT> map_fn>
static auto construct(bool in_is_migratable, IndexT in_range, bool in_dense_start_with_zero) -> ProxyType
static auto construct(bool in_is_migratable, IndexT in_range, bool in_dense_start_with_zero, vt::HandlerType map) -> ProxyType

Constructors, destructors, conversion operators

SubHandle() defaulted

Public functions

void initialize(ProxyType in_proxy, bool in_is_migratable, IndexT in_range, vt::HandlerType map_han, bool in_dense_start_with_zero)
void makeSubHandles(bool initial = true)
auto linearize(IndexT idx) -> IndexT::DenseIndexType
auto getHomeNode(IndexT const& idx) -> NodeType
auto fetchInfo(IndexT const& idx) -> IndexInfo
void updateInfo(IndexT const& idx, IndexInfo info, NodeType home)
auto resolveLocation(IndexT const& idx) -> IndexInfo
void get(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)
auto getCount(IndexT const& idx, Lock l = Lock::Shared) -> std::size_t
auto rget(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset) -> RequestHolder
auto rput(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset) -> RequestHolder
void put(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)
auto raccum(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset, MPI_Op op) -> RequestHolder
void accum(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset, MPI_Op op)
auto fetchOp(IndexT const& idx, Lock l, T ptr, int offset, MPI_Op op) -> T
auto isUniform() const -> bool
template<typename Callable>
void access(IndexT idx, Lock l, Callable fn, uint64_t offset)
auto addLocalIndex(IndexT index, uint64_t count) -> Handle<T, E, IndexT>
auto getOrderedOffset(IndexT idx, NodeType home_node) -> int
void stageLocalIndex(IndexT index, uint64_t count)
void migratedOutIndex(IndexT index)
void migratedInIndex(IndexT index)
void afterLB()
void checkChanged(impl::ReduceLBMsg* msg)
auto ready() const -> bool
auto totalLocalCount() const -> uint64_t
auto getNumHandles() const -> std::size_t
auto getNumActiveHandles() const -> std::size_t
void deleteHandle()
auto getNumDeletedHandles() const -> std::size_t
auto getCollectionExpected() const -> std::size_t
void setCollectionExpected(std::size_t count)
void destroy()

Protected variables

ProxyType proxy_
bool is_migratable_
vt::HandlerType map_han_
IndexT range_
std::unordered_map<IndexT, SubInfo> sub_handles_
std::unordered_map<IndexT, std::size_t> sub_handles_staged_
std::vector<IndexT> sub_layout_
std::vector<uint64_t> sub_prefix_
Handle<T, E> data_handle_
Handle<uint64_t, E> loc_handle_
Cache<IndexT> cache_
bool ready_
bool mpi2_
bool uniform_size_
std::size_t count_if_uniform_
std::size_t collection_expected_count_
std::vector<IndexT> migrate_out_
std::vector<IndexT> migrate_in_
bool ordered_opt_
std::unordered_map<IndexT, int> ordered_local_offset_
bool dense_start_with_zero_
std::size_t deleted_count_

Typedef documentation

template<typename T, HandleEnum E, typename IndexT>
using vt::rdma::SubHandle<T, E, IndexT>::HandleType = Handle<T, vt::rdma::HandleEnum::StaticSize, IndexT>

template<typename T, HandleEnum E, typename IndexT>
using vt::rdma::SubHandle<T, E, IndexT>::ProxyType = vt::objgroup::proxy::Proxy<SubHandle<T, E, IndexT>>

Function documentation

template<typename T, HandleEnum E, typename IndexT>
static void vt::rdma::SubHandle<T, E, IndexT>::destroyCollective(ProxyType proxy)

template<typename T, HandleEnum E, typename IndexT> template<mapping::ActiveMapTypedFnType<IndexT> map_fn>
static ProxyType vt::rdma::SubHandle<T, E, IndexT>::construct(bool in_is_migratable, IndexT in_range, bool in_dense_start_with_zero)

template<typename T, HandleEnum E, typename IndexT>
static ProxyType vt::rdma::SubHandle<T, E, IndexT>::construct(bool in_is_migratable, IndexT in_range, bool in_dense_start_with_zero, vt::HandlerType map)

template<typename T, HandleEnum E, typename IndexT>
vt::rdma::SubHandle<T, E, IndexT>::SubHandle() defaulted

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::initialize(ProxyType in_proxy, bool in_is_migratable, IndexT in_range, vt::HandlerType map_han, bool in_dense_start_with_zero)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::makeSubHandles(bool initial = true)

template<typename T, HandleEnum E, typename IndexT>
IndexT::DenseIndexType vt::rdma::SubHandle<T, E, IndexT>::linearize(IndexT idx)

template<typename T, HandleEnum E, typename IndexT>
NodeType vt::rdma::SubHandle<T, E, IndexT>::getHomeNode(IndexT const& idx)

template<typename T, HandleEnum E, typename IndexT>
IndexInfo vt::rdma::SubHandle<T, E, IndexT>::fetchInfo(IndexT const& idx)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::updateInfo(IndexT const& idx, IndexInfo info, NodeType home)

template<typename T, HandleEnum E, typename IndexT>
IndexInfo vt::rdma::SubHandle<T, E, IndexT>::resolveLocation(IndexT const& idx)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::get(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::getCount(IndexT const& idx, Lock l = Lock::Shared)

template<typename T, HandleEnum E, typename IndexT>
RequestHolder vt::rdma::SubHandle<T, E, IndexT>::rget(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)

template<typename T, HandleEnum E, typename IndexT>
RequestHolder vt::rdma::SubHandle<T, E, IndexT>::rput(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::put(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset)

template<typename T, HandleEnum E, typename IndexT>
RequestHolder vt::rdma::SubHandle<T, E, IndexT>::raccum(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset, MPI_Op op)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::accum(IndexT const& idx, Lock l, T* ptr, uint64_t len, int offset, MPI_Op op)

template<typename T, HandleEnum E, typename IndexT>
T vt::rdma::SubHandle<T, E, IndexT>::fetchOp(IndexT const& idx, Lock l, T ptr, int offset, MPI_Op op)

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::isUniform() const

template<typename T, HandleEnum E, typename IndexT> template<typename Callable>
void vt::rdma::SubHandle<T, E, IndexT>::access(IndexT idx, Lock l, Callable fn, uint64_t offset)

template<typename T, HandleEnum E, typename IndexT>
Handle<T, E, IndexT> vt::rdma::SubHandle<T, E, IndexT>::addLocalIndex(IndexT index, uint64_t count)

template<typename T, HandleEnum E, typename IndexT>
int vt::rdma::SubHandle<T, E, IndexT>::getOrderedOffset(IndexT idx, NodeType home_node)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::stageLocalIndex(IndexT index, uint64_t count)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::migratedOutIndex(IndexT index)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::migratedInIndex(IndexT index)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::afterLB()

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::checkChanged(impl::ReduceLBMsg* msg)

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::ready() const

template<typename T, HandleEnum E, typename IndexT>
uint64_t vt::rdma::SubHandle<T, E, IndexT>::totalLocalCount() const

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::getNumHandles() const

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::getNumActiveHandles() const

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::deleteHandle()

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::getNumDeletedHandles() const

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::getCollectionExpected() const

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::setCollectionExpected(std::size_t count)

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::SubHandle<T, E, IndexT>::destroy()

Variable documentation

template<typename T, HandleEnum E, typename IndexT>
ProxyType vt::rdma::SubHandle<T, E, IndexT>::proxy_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::is_migratable_ protected

template<typename T, HandleEnum E, typename IndexT>
vt::HandlerType vt::rdma::SubHandle<T, E, IndexT>::map_han_ protected

template<typename T, HandleEnum E, typename IndexT>
IndexT vt::rdma::SubHandle<T, E, IndexT>::range_ protected

template<typename T, HandleEnum E, typename IndexT>
std::unordered_map<IndexT, SubInfo> vt::rdma::SubHandle<T, E, IndexT>::sub_handles_ protected

template<typename T, HandleEnum E, typename IndexT>
std::unordered_map<IndexT, std::size_t> vt::rdma::SubHandle<T, E, IndexT>::sub_handles_staged_ protected

template<typename T, HandleEnum E, typename IndexT>
std::vector<IndexT> vt::rdma::SubHandle<T, E, IndexT>::sub_layout_ protected

template<typename T, HandleEnum E, typename IndexT>
std::vector<uint64_t> vt::rdma::SubHandle<T, E, IndexT>::sub_prefix_ protected

template<typename T, HandleEnum E, typename IndexT>
Handle<T, E> vt::rdma::SubHandle<T, E, IndexT>::data_handle_ protected

template<typename T, HandleEnum E, typename IndexT>
Handle<uint64_t, E> vt::rdma::SubHandle<T, E, IndexT>::loc_handle_ protected

template<typename T, HandleEnum E, typename IndexT>
Cache<IndexT> vt::rdma::SubHandle<T, E, IndexT>::cache_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::ready_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::mpi2_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::uniform_size_ protected

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::count_if_uniform_ protected

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::collection_expected_count_ protected

template<typename T, HandleEnum E, typename IndexT>
std::vector<IndexT> vt::rdma::SubHandle<T, E, IndexT>::migrate_out_ protected

template<typename T, HandleEnum E, typename IndexT>
std::vector<IndexT> vt::rdma::SubHandle<T, E, IndexT>::migrate_in_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::ordered_opt_ protected

template<typename T, HandleEnum E, typename IndexT>
std::unordered_map<IndexT, int> vt::rdma::SubHandle<T, E, IndexT>::ordered_local_offset_ protected

template<typename T, HandleEnum E, typename IndexT>
bool vt::rdma::SubHandle<T, E, IndexT>::dense_start_with_zero_ protected

template<typename T, HandleEnum E, typename IndexT>
std::size_t vt::rdma::SubHandle<T, E, IndexT>::deleted_count_ protected