vt::rdma::Manager struct
#include <src/vt/rdmahandle/manager.h>

RDMA Handle Manager for creation of node- or index-level handles.

Base classes

template<typename T> struct vt::runtime::component::Component<Manager>: Component class for a generic VT runtime module, CRTP'ed over the component's actual type

Public types

using ProxyType = vt::objgroup::proxy::Proxy<Manager>
using ElemToHandle = std::unordered_map<int64_t, RDMA_HandleType>
using HandleToManager = std::unordered_map<RDMA_HandleType, ObjGroupProxyType>
using CollectiveScopeType = collective::CollectiveScope

Public static functions

static auto construct() -> std::unique_ptr<Manager>

Constructors, destructors, conversion operators

Manager()

Public functions

auto name() -> std::string override: Get the name of the component.
void finalize() override: Destroy the component, called when VT is finalized.
template<typename T, HandleEnum E, typename ProxyT> auto makeHandleCollectiveObjGroup(ProxyT proxy, std::size_t count, bool uniform_count = true) -> Handle<T, E>: Construct a new, distributed RDMA handle for an objgroup.
template<typename T, HandleEnum E, typename ProxyT, typename LookupT = typename HandleSet<T>::LookupType> auto makeHandleSetCollectiveObjGroup(ProxyT proxy_objgroup, LookupT max_lookup, std::unordered_map<LookupT, std::size_t> const& map, bool dense_start_with_zero, bool uniform_size = true) -> HandleSet<T>: Construct a static (non-migratable) set of new, distributed RDMA handles for an objgroup.
template<typename T, HandleEnum E, typename ColT, typename ProxyT, typename IndexT = typename ColT::IndexType> auto makeCollectionHandles(ProxyT collection_proxy, std::size_t idx_count, bool uniform_size = true, RDMA_HandleType next_handle = no_rdma_handle, vt::HandlerType map_han = -1, IndexT in_range = {}) -> Handle<T, E, IndexT>: Construct a migratable set of new, distributed RDMA handles for a collection.
template<typename T, HandleEnum E> void deleteHandleCollectiveObjGroup(Handle<T, E> const& han): Destroy and garbage collect an RDMA handle.
template<typename T> void deleteHandleSetCollectiveObjGroup(HandleSet<T>& han): Destroy and garbage collect an RDMA handle.
template<typename T, HandleEnum E, typename IndexT> void deleteHandleCollection(Handle<T, E, IndexT>& han): Destroy and garbage collect a handle from a collection.
template<typename T, HandleEnum E> auto getEntry(HandleKey const& key) -> Holder<T, E>&
template<typename SerializerT> void serialize(SerializerT& s)
template<typename T, HandleEnum E, typename ProxyT, typename LookupT> auto makeHandleSetCollectiveObjGroup(ProxyT, LookupT max_lookup, std::unordered_map<LookupT, std::size_t> const& map, bool dense_start_with_zero, ] bool uniform_size) -> HandleSet<T>

Function documentation

template<typename T, HandleEnum E, typename ProxyT>
Handle<T, E> vt::rdma::Manager::makeHandleCollectiveObjGroup(ProxyT proxy, std::size_t count, bool uniform_count = true)

Construct a new, distributed RDMA handle for an objgroup.

Parameters
proxy in	the objgroup's proxy
count in	the local count of T for this handle
uniform_count in	whether all handles have the same count
Returns	the new handle

template<typename T, HandleEnum E, typename ProxyT, typename LookupT = typename HandleSet<T>::LookupType>
HandleSet<T> vt::rdma::Manager::makeHandleSetCollectiveObjGroup(ProxyT proxy_objgroup, LookupT max_lookup, std::unordered_map<LookupT, std::size_t> const& map, bool dense_start_with_zero, bool uniform_size = true)

Construct a static (non-migratable) set of new, distributed RDMA handles for an objgroup.

Parameters
proxy_objgroup
max_lookup in	the max lookup on any node
map in	a map of the handles and corresponding sizes to create
dense_start_with_zero in	handle indices are dense and start at zero
uniform_size in	whether all handles have the same size
Returns	the new handle set

template<typename T, HandleEnum E, typename ColT, typename ProxyT, typename IndexT = typename ColT::IndexType>
Handle<T, E, IndexT> vt::rdma::Manager::makeCollectionHandles(ProxyT collection_proxy, std::size_t idx_count, bool uniform_size = true, RDMA_HandleType next_handle = no_rdma_handle, vt::HandlerType map_han = -1, IndexT in_range = {})

Construct a migratable set of new, distributed RDMA handles for a collection.

Parameters
collection_proxy in	the collection proxy with index
idx_count in	the local count of T for this handle
uniform_size in	whether all handles have the same size
next_handle in	system-use-only, the handle ID
map_han in	system-use-only, element map for collection
in_range in	system-use-only, range for collection
Returns	the new handle set

template<typename T, HandleEnum E>
void vt::rdma::Manager::deleteHandleCollectiveObjGroup(Handle<T, E> const& han)

Destroy and garbage collect an RDMA handle.

Parameters
han in	the handle to destroy

template<typename T>
void vt::rdma::Manager::deleteHandleSetCollectiveObjGroup(HandleSet<T>& han)

Destroy and garbage collect an RDMA handle.

Parameters
han in	the handle to destroy

template<typename T, HandleEnum E, typename IndexT>
void vt::rdma::Manager::deleteHandleCollection(Handle<T, E, IndexT>& han)

Destroy and garbage collect a handle from a collection.

Parameters
han in	the handle to destroy

#include <src/vt/rdmahandle/manager.impl.h>

template<typename T, HandleEnum E, typename ProxyT, typename LookupT>
HandleSet<T> vt::rdma::Manager::makeHandleSetCollectiveObjGroup(ProxyT, LookupT max_lookup, std::unordered_map<LookupT, std::size_t> const& map, bool dense_start_with_zero, ] bool uniform_size)

vt::rdma::Manager struct #include <src/vt/rdmahandle/manager.h>