vt::auto_registry namespace

Classes

template<typename FnT>
struct AutoRegInfo
struct BaseHandlersDispatcher
struct BaseMapsDispatcher
struct BaseScatterDispatcher
template<typename F, F* f, typename MsgT = void, typename ObjT = SentinelObject>
struct FunctorAdapter
template<typename ObjTypeT, typename MsgT, bool is_msg_direct>
struct FunctorAdapterArgs
template<typename F, F f, typename ObjT = void, typename MsgT = void>
struct FunctorAdapterMember
template<typename F, F f, typename MsgT>
struct FunctorAdapterParam
template<typename FunctorT, bool is_msg_direct, typename MsgT>
struct GetFnPtr
template<typename FunctorT, typename MsgT>
struct GetFnPtr<FunctorT, false, MsgT>
template<typename FunctorT, typename MsgT>
struct GetFnPtr<FunctorT, true, MsgT>
template<typename MsgT, typename HandlerT, typename ObjT>
struct HandlersDispatcher
template<typename IndexT>
struct IndexHolder
template<typename IndexT, typename HandlerT>
struct MapsDispatcher
template<typename = void>
struct MaxIndexHolder
struct NumArgsTagType
template<typename FunctorT, typename RegT, typename InfoT, typename FnT, typename = void>
struct RegistrarFunctor
template<typename AdapterT, typename RegT, typename InfoT, typename FnT>
struct RegistrarGen
struct RegistrarGenInfo
struct RegistrarGenInfoBase
template<typename RegObjTypeT>
struct RegistrarGenInfoImpl
template<typename RunnableT, typename RegT, typename InfoT, typename FnT, typename = void>
struct RegistrarHelper
template<typename IndexT>
struct RegistrarIndex
template<typename FunctorT, typename RegT, typename InfoT, typename FnT>
struct RegistrarWrapperFunctor
template<typename AdapterT, typename RegT, typename InfoT, typename FnT>
struct RegistrarWrapperGen
template<typename IndexT>
struct RegistrarWrapperIndex
template<typename AdapterT, typename RegT, typename InfoT, typename FnT, typename MsgT>
struct RunnableFunctor
template<typename AdapterT, typename RegT, typename InfoT, typename FnT>
struct RunnableGen
template<typename MsgT, typename HandlerT, typename ObjT>
struct ScatterDispatcher
struct SentinelObject
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarHelper<RunnableT, RegT, InfoT, FnT, std::enable_if_t<std::is_same<InfoT, AutoRegInfo<BaseScatterDispatcherPtr>>::value>>
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarFunctor<RunnableT, RegT, InfoT, FnT, std::enable_if_t<std::is_same<InfoT, AutoRegInfo<AutoActiveType>>::value>>
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarHelper<RunnableT, RegT, InfoT, FnT, std::enable_if_t<std::is_same<InfoT, AutoRegInfo<BaseHandlersDispatcherPtr>>::value>>
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarHelper<RunnableT, RegT, InfoT, FnT, std::enable_if_t<std::is_same<InfoT, AutoRegInfo<BaseMapsDispatcherPtr>>::value>>
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarHelper<RunnableT, RegT, InfoT, FnT, std::enable_if_t<not std::is_same<InfoT, AutoRegInfo<BaseHandlersDispatcherPtr>>::value and not std::is_same<InfoT, AutoRegInfo<BaseMapsDispatcherPtr>>::value and not std::is_same<InfoT, AutoRegInfo<BaseScatterDispatcherPtr>>::value>>
template<typename RunnableT, typename RegT, typename InfoT, typename FnT>
struct RegistrarFunctor<RunnableT, RegT, InfoT, FnT, std::enable_if_t<std::is_same<InfoT, AutoRegInfo<AutoActiveMapType>>::value>>

Enums

enum class RegistryTypeEnum { RegGeneral = 1, RegMap, RegVrt, RegSeed, RegVrtCollection, RegVrtCollectionMember, RegRDMAGet, RegRDMAPut, RegIndex, RegObjGroup }

Typedefs

using BaseHandlersDispatcherPtr = std::unique_ptr<BaseHandlersDispatcher>
using BaseMapsDispatcherPtr = std::unique_ptr<BaseMapsDispatcher>
using BaseScatterDispatcherPtr = std::unique_ptr<BaseScatterDispatcher>
using AutoActiveType = BaseHandlersDispatcherPtr
using AutoActiveFunctorType = BaseHandlersDispatcherPtr
using AutoActiveVCType = BaseHandlersDispatcherPtr
using AutoActiveCollectionType = BaseHandlersDispatcherPtr
using AutoActiveCollectionMemType = BaseHandlersDispatcherPtr
using AutoActiveObjGroupType = BaseHandlersDispatcherPtr
using AutoActiveMapType = BaseMapsDispatcherPtr
using AutoActiveMapFunctorType = BaseMapsDispatcherPtr
using AutoActiveSeedMapType = mapping::ActiveSeedMapFnPtrType
using AutoActiveRDMAGetType = ActiveRDMAGetFnPtrType
using AutoActiveRDMAPutType = ActiveRDMAPutFnPtrType
using AutoActiveIndexType = std::size_t
using HandlerManagerType = vt::HandlerManager
using AutoHandlerType = HandlerType
using NumArgsType = int16_t
template<typename Fn>
using AutoRegInfoType = AutoRegInfo<Fn>
template<typename RegInfoT>
using RegContType = std::vector<AutoRegInfoType<RegInfoT>>
using AutoActiveContainerType = RegContType<AutoActiveType>
using AutoActiveVCContainerType = RegContType<AutoActiveVCType>
using AutoActiveCollectionContainerType = RegContType<AutoActiveCollectionType>
using AutoActiveCollectionMemContainerType = RegContType<AutoActiveCollectionMemType>
using AutoActiveMapContainerType = RegContType<AutoActiveMapType>
using AutoActiveMapFunctorContainerType = RegContType<AutoActiveMapFunctorType>
using AutoActiveSeedMapContainerType = RegContType<AutoActiveSeedMapType>
using AutoActiveFunctorContainerType = RegContType<AutoActiveFunctorType>
using AutoActiveRDMAGetContainerType = RegContType<AutoActiveRDMAGetType>
using AutoActiveRDMAPutContainerType = RegContType<AutoActiveRDMAPutType>
using AutoActiveIndexContainerType = RegContType<AutoActiveIndexType>
using AutoActiveObjGroupContainerType = RegContType<AutoActiveObjGroupType>
using ScatterContainerType = RegContType<BaseScatterDispatcherPtr>

Functions

auto getAutoHandler(HandlerType const handler) -> AutoActiveType const &
auto getAutoHandlerObjGroup(HandlerType han) -> AutoActiveObjGroupType const &
auto getAutoHandlerObjTypeIdx(HandlerType han) -> AutoHandlerType
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
auto makeAutoHandlerObjGroup(HandlerControlType control) -> HandlerType
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
auto makeAutoHandler(MsgT*const msg) -> HandlerType
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
auto makeAutoHandler() -> HandlerType
template<typename T, T value>
auto makeAutoHandlerParam() -> HandlerType
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
void setHandlerTraceNameObjGroup(HandlerControlType ctrl, std::string const& name, std::string const& parent = "")
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
void setHandlerTraceName(std::string const& name, std::string const& parent = "")
template<typename T, typename... Args>
static auto proxyOperatorToNewInstanceReg(Args... args) -> auto
template<typename RegT, typename = void>
auto getAutoRegistryGen() -> RegT&
template<typename AdapterT, typename RegT, typename InfoT, typename FnT>
auto registerActiveGen() -> AutoHandlerType
template<typename ObjT, typename T, T value, typename MsgT>
auto makeAutoHandlerObjGroupParam(HandlerControlType ctrl) -> HandlerType
template<typename MessageT, ActiveTypedFnType<MessageT>* f>
auto makeScatterHandler() -> HandlerType
auto getScatterAutoHandler(HandlerType const handler) -> BaseScatterDispatcherPtr const &
template<typename T, T value, typename MsgT>
auto makeAutoHandlerParam() -> HandlerType
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
void setHandlerTraceNameObjGroup(] HandlerControlType ctrl, ] std::string const& name, ] std::string const& parent)
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
void setHandlerTraceName(] std::string const& name, ] std::string const& parent)
template<typename T, bool is_msg, typename... Args>
auto makeAutoHandlerFunctor() -> HandlerType
auto getAutoHandlerFunctor(HandlerType const handler) -> AutoActiveFunctorType const &
auto getAutoHandlerCollection(HandlerType const handler) -> AutoActiveCollectionType const &
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
auto makeAutoHandlerCollection() -> HandlerType
auto getAutoHandlerCollectionMem(HandlerType const handler) -> AutoActiveCollectionMemType const &
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
auto makeAutoHandlerCollectionMem() -> HandlerType
template<typename ColT, typename T, T value, typename MsgT>
auto makeAutoHandlerCollectionMemParam() -> HandlerType
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
void setHandlerTraceNameColl(std::string const& name, std::string const& parent = "")
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
void setHandlerTraceNameCollMem(std::string const& name, std::string const& parent = "")
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
void setHandlerTraceNameColl(] std::string const& name, ] std::string const& parent)
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
void setHandlerTraceNameCollMem(] std::string const& name, ] std::string const& parent)
auto getAutoHandlerFunctorArgs(HandlerType const handler) -> NumArgsType
template<typename FunctorT, typename RegT, typename InfoT, typename FnT>
auto registerActiveFunctor() -> AutoHandlerType
auto getMaxIndexSize() -> std::size_t
template<typename IndexT>
auto makeAutoIndex() -> AutoHandlerType
template<typename IndexT>
auto registerIndex() -> AutoHandlerType
auto getAutoHandlerFunctorMap(HandlerType const han) -> AutoActiveMapType const &
template<typename FunctorT>
auto makeAutoHandlerFunctorMap() -> HandlerType
auto getAutoHandlerMap(HandlerType const handler) -> AutoActiveMapType const &
template<typename IndexT, ActiveMapTypedFnType<IndexT>* f>
auto makeAutoHandlerMap() -> HandlerType
auto getAutoHandlerSeedMap(HandlerType const handler) -> AutoActiveSeedMapType
template<ActiveSeedMapFnType* f>
auto makeAutoHandlerSeedMap() -> HandlerType
auto getHandlerMap(HandlerType const han) -> AutoActiveMapType const &
auto getAutoHandlerRDMAGet(HandlerType const handler) -> AutoActiveRDMAGetType
auto getAutoHandlerRDMAPut(HandlerType const handler) -> AutoActiveRDMAPutType
template<typename MsgT, ActiveTypedRDMAPutFnType<MsgT>* f>
auto makeAutoHandlerRDMAPut() -> HandlerType
template<typename MsgT, ActiveTypedRDMAGetFnType<MsgT>* f>
auto makeAutoHandlerRDMAGet() -> HandlerType
auto getAutoHandlerVC(HandlerType const handler) -> AutoActiveVCType const &
template<typename VrtT, typename MsgT, ActiveVrtTypedFnType<MsgT, VrtT>* f>
auto makeAutoHandlerVC() -> HandlerType

Variables

static struct vt::auto_registry::NumArgsTagType NumArgsTag

Enum documentation

Typedef documentation

using vt::auto_registry::BaseMapsDispatcherPtr = std::unique_ptr<BaseMapsDispatcher>
#include <src/vt/registry/auto/auto_registry_common.h>

using vt::auto_registry::AutoActiveIndexType = std::size_t
#include <src/vt/registry/auto/auto_registry_common.h>

using vt::auto_registry::NumArgsType = int16_t
#include <src/vt/registry/auto/auto_registry_common.h>

#include <src/vt/registry/auto/auto_registry_common.h>
template<typename Fn>
using vt::auto_registry::AutoRegInfoType = AutoRegInfo<Fn>

#include <src/vt/registry/auto/auto_registry_common.h>
template<typename RegInfoT>
using vt::auto_registry::RegContType = std::vector<AutoRegInfoType<RegInfoT>>

Function documentation

#include <src/vt/registry/auto/auto_registry.h>
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
HandlerType vt::auto_registry::makeAutoHandlerObjGroup(HandlerControlType control)

#include <src/vt/registry/auto/auto_registry.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
HandlerType vt::auto_registry::makeAutoHandler(MsgT*const msg)

#include <src/vt/registry/auto/auto_registry_interface.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
HandlerType vt::auto_registry::makeAutoHandler()

#include <src/vt/registry/auto/auto_registry.h>
template<typename T, T value>
HandlerType vt::auto_registry::makeAutoHandlerParam()

#include <src/vt/registry/auto/auto_registry.h>
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
void vt::auto_registry::setHandlerTraceNameObjGroup(HandlerControlType ctrl, std::string const& name, std::string const& parent = "")

#include <src/vt/registry/auto/auto_registry.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
void vt::auto_registry::setHandlerTraceName(std::string const& name, std::string const& parent = "")

#include <src/vt/registry/auto/auto_registry_general.h>
template<typename T, typename... Args>
static auto vt::auto_registry::proxyOperatorToNewInstanceReg(Args... args)

#include <src/vt/registry/auto/auto_registry_general.h>
template<typename RegT, typename = void>
RegT& vt::auto_registry::getAutoRegistryGen()

#include <src/vt/registry/auto/auto_registry_general.h>
template<typename AdapterT, typename RegT, typename InfoT, typename FnT>
AutoHandlerType vt::auto_registry::registerActiveGen()

#include <src/vt/registry/auto/auto_registry_impl.h>
template<typename ObjT, typename T, T value, typename MsgT>
HandlerType vt::auto_registry::makeAutoHandlerObjGroupParam(HandlerControlType ctrl)

#include <src/vt/registry/auto/auto_registry_impl.h>
template<typename MessageT, ActiveTypedFnType<MessageT>* f>
HandlerType vt::auto_registry::makeScatterHandler()

#include <src/vt/registry/auto/auto_registry_impl.h>
template<typename T, T value, typename MsgT>
HandlerType vt::auto_registry::makeAutoHandlerParam()

#include <src/vt/registry/auto/auto_registry_impl.h>
template<typename ObjT, typename MsgT, objgroup::ActiveObjType<MsgT, ObjT> f>
void vt::auto_registry::setHandlerTraceNameObjGroup(] HandlerControlType ctrl, ] std::string const& name, ] std::string const& parent)

#include <src/vt/registry/auto/auto_registry_impl.h>
template<typename MsgT, ActiveTypedFnType<MsgT>* f>
void vt::auto_registry::setHandlerTraceName(] std::string const& name, ] std::string const& parent)

#include <src/vt/registry/auto/auto_registry_interface.h>
template<typename T, bool is_msg, typename... Args>
HandlerType vt::auto_registry::makeAutoHandlerFunctor()

#include <src/vt/registry/auto/collection/auto_registry_collection.h>
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
HandlerType vt::auto_registry::makeAutoHandlerCollection()

#include <src/vt/registry/auto/collection/auto_registry_collection.h>
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
HandlerType vt::auto_registry::makeAutoHandlerCollectionMem()

#include <src/vt/registry/auto/collection/auto_registry_collection.h>
template<typename ColT, typename T, T value, typename MsgT>
HandlerType vt::auto_registry::makeAutoHandlerCollectionMemParam()

#include <src/vt/registry/auto/collection/auto_registry_collection.h>
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
void vt::auto_registry::setHandlerTraceNameColl(std::string const& name, std::string const& parent = "")

#include <src/vt/registry/auto/collection/auto_registry_collection.h>
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
void vt::auto_registry::setHandlerTraceNameCollMem(std::string const& name, std::string const& parent = "")

#include <src/vt/registry/auto/collection/auto_registry_collection.impl.h>
template<typename ColT, typename MsgT, ActiveColTypedFnType<MsgT, ColT>* f>
void vt::auto_registry::setHandlerTraceNameColl(] std::string const& name, ] std::string const& parent)

#include <src/vt/registry/auto/collection/auto_registry_collection.impl.h>
template<typename ColT, typename MsgT, ActiveColMemberTypedFnType<MsgT, ColT> f>
void vt::auto_registry::setHandlerTraceNameCollMem(] std::string const& name, ] std::string const& parent)

#include <src/vt/registry/auto/functor/auto_registry_functor.h>
template<typename FunctorT, typename RegT, typename InfoT, typename FnT>
AutoHandlerType vt::auto_registry::registerActiveFunctor()

std::size_t vt::auto_registry::getMaxIndexSize()
#include <src/vt/registry/auto/index/auto_registry_index.h>

#include <src/vt/registry/auto/index/auto_registry_index.h>
template<typename IndexT>
AutoHandlerType vt::auto_registry::makeAutoIndex()

#include <src/vt/registry/auto/index/auto_registry_index_reg.h>
template<typename IndexT>
AutoHandlerType vt::auto_registry::registerIndex()

#include <src/vt/registry/auto/map/auto_registry_map.h>
template<typename FunctorT>
HandlerType vt::auto_registry::makeAutoHandlerFunctorMap()

#include <src/vt/registry/auto/map/auto_registry_map.h>
template<typename IndexT, ActiveMapTypedFnType<IndexT>* f>
HandlerType vt::auto_registry::makeAutoHandlerMap()

#include <src/vt/registry/auto/map/auto_registry_map.h>
template<ActiveSeedMapFnType* f>
HandlerType vt::auto_registry::makeAutoHandlerSeedMap()

#include <src/vt/registry/auto/rdma/auto_registry_rdma.h>
template<typename MsgT, ActiveTypedRDMAPutFnType<MsgT>* f>
HandlerType vt::auto_registry::makeAutoHandlerRDMAPut()

#include <src/vt/registry/auto/rdma/auto_registry_rdma.h>
template<typename MsgT, ActiveTypedRDMAGetFnType<MsgT>* f>
HandlerType vt::auto_registry::makeAutoHandlerRDMAGet()

#include <src/vt/registry/auto/vc/auto_registry_vc.h>
template<typename VrtT, typename MsgT, ActiveVrtTypedFnType<MsgT, VrtT>* f>
HandlerType vt::auto_registry::makeAutoHandlerVC()

Variable documentation

static struct vt::auto_registry::NumArgsTagType vt::auto_registry::NumArgsTag
#include <src/vt/registry/auto/auto_registry_common.h>