vt namespace
Namespaces
- namespace adt
- namespace arguments
- namespace auto_registry
- namespace CLI
- namespace collective
- namespace config
- namespace ctx
- namespace debug
- namespace detail
- namespace diagnostic
- namespace elm
- namespace epoch
- namespace error
- namespace event
- namespace group
- namespace index
- namespace location
- namespace mapping
- namespace messaging
- namespace objgroup
- namespace param
- namespace phase
- namespace pipe
- namespace pool
- namespace rdma
- namespace runnable
- namespace runtime
- namespace sched
- namespace serialization
- namespace standalone
- namespace term
- namespace termination
- namespace timetrigger
- namespace timing
- namespace trace
- namespace util
- namespace utils
- namespace vrt
Classes
-
template<typename... Args>struct CBTraits
-
template<runtime::struct CollectiveAnyOps
RuntimeInstType instance = collective_default_inst> - struct EpochGuard
- An epoch wrapper that provides an RAII-style mechanism for owning an epoch for the duration of a scope block.
- struct EventCheckFinishedMsg
- struct EventFinishedMsg
- struct from_s
-
template<typename... Args>struct FunctorTraits
-
template<typename... Args>struct FuncTraits
- struct HandlerManager
- struct MsgProps
-
template<typename... Args>struct ObjFuncTraits
-
template<typename EnvelopeT, typename SizeT>struct PutEnvelope
- Extended envelope for holding control bits for a message packed with a put payload.
- struct StrongNodeType
- struct TimeTypeWrapper
- struct to_s
Enums
- enum eHandlerBits { Auto = 0, Functor = eHandlerBits::Auto + auto_num_bits, Trace = eHandlerBits::Functor + functor_num_bits, Control = eHandlerBits::Trace + trace_num_bits, BaseMsgDerived = eHandlerBits::Control + control_num_bits, RegistryType = eHandlerBits::BaseMsgDerived + base_msg_derived_num_bits, Identifier = eHandlerBits::RegistryType + registry_type_bits }
Typedefs
-
using ActiveClosureFnType = std::function<void(vt::
BaseMessage*)> -
using ActiveFnType = void(vt::
BaseMessage*) -
using ActiveFnPtrType = void(*)(vt::
BaseMessage*) - using ActiveVoidFnType = void()
- using ActiveTypedFnType = void(MessageT*)
-
using ActiveClosureRDMAGetFnType = std::function<RDMA_
GetType(vt:: BaseMessage*, ByteType, ByteType, TagType, bool)> -
using ActiveRDMAGetFnPtrType = RDMA_
GetType(*)(vt:: BaseMessage*, ByteType, ByteType, TagType, bool) -
using ActiveTypedRDMAGetFnType = RDMA_
GetType(MessageT*, ByteType, ByteType, TagType, bool) -
using ActiveClosureRDMAPutFnType = std::function<void(vt::
BaseMessage*, RDMA_ PtrType, ByteType, ByteType, TagType, bool)> -
using ActiveRDMAPutFnPtrType = void(*)(vt::
BaseMessage*, RDMA_ PtrType, ByteType, ByteType, TagType, bool) -
using ActiveTypedRDMAPutFnType = void(MessageT*, RDMA_
PtrType, ByteType, ByteType, TagType, bool) - using CollectiveOps = CollectiveAnyOps<collective_default_inst>
- using RDMA_PtrType = std::byte*
- using RDMA_ElmType = uint64_t
- using RDMA_BlockType = int64_t
- using RDMA_HandleType = int64_t
- using RDMA_HandlerType = int64_t
-
using RDMA_GetType = std::tuple<RDMA_
PtrType, ByteType> -
using RDMA_PutRetType = RDMA_
GetType -
using RDMA_ContinuationType = std::function<void(RDMA_
GetType)> -
using RDMA_ContinuationDeleteType = std::function<void(RDMA_
GetType, ActionType)> -
using RDMA_PutSerialize = std::function<RDMA_
PutRetType(RDMA_ PutRetType)> - using PhysicalResourceType = int16_t
- using NodeType = PhysicalResourceType
- Used to hold the current node/rank or the number of nodes.
- using CoreType = PhysicalResourceType
- Used to hold a core ID.
- using HandlerType = int64_t
- Used to hold a handler ID which identifier a function pointer/context.
- using SeedType = int64_t
- Used to hold a seed for random generation.
- using EnvelopeDataType = int8_t
- Used to hold the control bits in an envelope.
- using EventType = uint64_t
- Used to hold a local/remote event to wait for completion.
- using SequentialIDType = uint64_t
- Used to hold a sequential identifier for ordered/stateful operations.
- using TagType = int32_t
- Used to hold an tag, e.g., on messages or reduces.
- using BarrierType = uint64_t
- Used to identify a specific barrier.
- using CollectiveAlgType = uint64_t
- Used to identify a collective operation.
- using RefType = uint16_t
- Used to hold the reference count for messages.
- using PipeRefType = int16_t
- Used to hold the reference count for messages in pipes.
- using ByteType = uint64_t
- Used to store some number of bytes.
- using BitCountType = int32_t
- Used to store the number of bits in a field.
- using SerialByteType = char
- Used to store the number of bits for serialization.
- using ErrorCodeType = int32_t
- Used to store an error code.
- using VirtualProxyType = uint64_t
- Used to hold an identifier for a collection or other proxy.
- using VirtualElmOnlyProxyType = uint64_t
- Used to hold an identifier for an element in a collection.
- using VirtualElmCountType = int64_t
- Used to hold the count of elements in a collection.
- using UniqueIndexBitType = uint64_t
- Used for mapping between index to contiguous bits.
- using GroupType = uint64_t
- Used for hold an identifier for a group.
- using MsgSizeType = int64_t
- Used for hold the size of a message.
- using PhaseType = uint64_t
- Used for hold a phase for load balancing.
- using LoadType = double
- LoadType used for load balancing.
- using SubphaseType = uint16_t
- Used for hold a sub-phase for load balancing.
- using PipeType = uint64_t
- Used for hold the identifier for a pipe (callbacks)
- using ObjGroupProxyType = uint64_t
- Used for hold the proxy ID for an objgroup.
- using PriorityType = uint16_t
- Used for hold the priority of a message.
- using PriorityLevelType = uint8_t
- Used for hold the level for a priority of a message.
- using ComponentIDType = uint32_t
- Used for hold a unique ID for each component.
- using ThreadIDType = uint64_t
- Used to hold a unique ID for a user-level thread on a particular node.
- using ActionType = std::function<void()>
- Used for generically store an action to perform.
- using ActionProxyType = std::function<void(VirtualProxyType)>
- Used for generically store an action that requires a proxy.
- using ActionNodeType = std::function<void(NodeType)>
- Used for generically store an action that requires a node.
-
using EpochType = epoch::
EpochType - The strong epoch type for holding a epoch for termination detection.
-
using EventRecordType = event::
EventRecord - using HandlerIdentifierType = uint64_t
- using HandlerControlType = uint32_t
- using PtrLenPairType = std::tuple<std::byte*, ByteType>
- A pair of a std::byte* and number of bytes (length) for sending data.
- using ContinuationDeleterType = std::function<void(PtrLenPairType data, ActionType deleter)>
- A continuation function with an allocated pointer with a deleter function.
- using Node = Strong<NodeType, uninitialized_destination, StrongNodeType>
-
using Active = messaging::
ActiveMessenger -
using Envelope = messaging::
ActiveEnvelope -
using EpochEnvelope = messaging::
EpochActiveEnvelope -
using TagEnvelope = messaging::
TagActiveEnvelope -
using EpochTagEnvelope = messaging::
EpochTagActiveEnvelope -
using eEnvType = messaging::
eEnvelopeType - using PutPtrType = std::byte*
- using PutPtrConstType = std::byte const *
- using PutEnvSizeType = size_t
- using PutUnderEnvelopeT = EpochTagEnvelope
- using PutShortEnvelope = PutEnvelope<EpochTagEnvelope, size_t>
-
using BaseMessage = messaging::
BaseMsg - Alias to the base of all messages.
-
using ActiveMessage = messaging::
ActiveMsg<EnvelopeT> - Alias to the a message with any envelope.
-
using ShortMessage = messaging::
ActiveMsg<Envelope> - Alias to the shortest message available with no epoch or tag allowed.
-
using EpochMessage = messaging::
ActiveMsg<EpochEnvelope> - Alias to a message with only an epoch.
-
using EpochTagMessage = messaging::
ActiveMsg<EpochTagEnvelope> - Alias to a message with an epoch and tag.
- using Message = EpochTagMessage
- Alias to the default message (with an epoch and tag)
- using BaseMsgType = ShortMessage
-
using NonSerialized = vt::
messaging:: NonSerializedMsg<MsgT, SelfT> -
using SerializeSupported = vt::
messaging:: SerializeSupportedMsg<MsgT, SelfT> -
using SerializeRequired = vt::
messaging:: SerializeRequiredMsg<MsgT, SelfT> -
using SerializeIfNeeded = vt::
messaging:: SerializeIfNeededMsg<MsgT, SelfT, DepTypesT...> -
using PayloadMessage = messaging::
PutMessageComponent<ActiveMessage<PutShortEnvelope>> -
using MsgVirtualPtr = messaging::
MsgSharedPtr<T> -
using MsgVirtualPtrAny = messaging::
MsgSharedPtr<ShortMessage> -
using MsgSharedPtr = messaging::
MsgSharedPtr<T> -
using MsgPtr = messaging::
MsgSharedPtr<T> - Wrapper to manage Active Messages.
-
using Callback = pipe::
callback:: cbunion:: CallbackTyped<Args...> -
using CallbackU = pipe::
callback:: cbunion:: CallbackRawBaseSingle -
using RDMA_TargetType = rdma::
Target -
using RDMA_NonTargetType = rdma::
NonTarget -
using HandleRDMA = rdma::
Handle<T, rdma:: HandleEnum:: StaticSize, I> -
using Lock = rdma::
Lock -
using CollectionManagerType = vrt::
collection:: CollectionManager -
using NodeLBDataType = vrt::
collection:: balance:: NodeLBData -
using LBDataRestartReaderType = vrt::
collection:: balance:: LBDataRestartReader -
using LBManagerType = vrt::
collection:: balance:: LBManager -
using TimeTriggerManagerType = timetrigger::
TimeTriggerManager -
using RuntimeType = runtime::
RuntimeHolderType -
using RuntimeUnsafePtrType = runtime::
RuntimeHolderUnsafePtrType - using RuntimePtrType = RuntimeType
-
using SerializedMessenger = ::vt::
serialization:: SerializedMessenger -
using IntegralSet = term::
interval:: IntegralSetBase<DomainT, DomainT{}, std::allocator, term:: interval:: Interval, std::set, IntervalCompare> -
using IntervalCompare = term::
interval:: IntervalCompare<DomainT> -
using Interval = term::
interval:: Interval<DomainT> -
using StrongIntegralSet = term::
interval:: StrongIntegralSet<T> - using TimeType = TimeTypeWrapper
-
using DenseIndex = index::
DenseIndexArray<IndexType, ndim> -
using IdxBase = index::
IdxBase -
using Index1D = index::
Index1D<index:: IdxBase> -
using Index2D = index::
Index2D<index:: IdxBase> -
using Index3D = index::
Index3D<index:: IdxBase> -
using IndexND = index::
IdxType<index:: IdxBase, N> -
using IdxType = index::
IdxType<T, N> -
using IdxType1D = index::
Index1D<T> -
using IdxType2D = index::
Index2D<T> -
using IdxType3D = index::
Index3D<T> -
using LocationRoutedMsg = location::
EntityMsg<EntityID, ActiveMessageT> -
using BitCounterType = utils::
BitCounter<T> -
using BitPackerType = utils::
BitPacker -
using NoMsg = util::
fntraits:: detail:: NoMsg -
using Strong = util::
strong:: detail:: Strong<T, init_val, Tag> - Type-alias for strong types.
-
using CollectionMessage = vrt::
collection:: CollectionMessage<ColT, MsgT> -
using Collection = vrt::
collection:: Collection<ColT, IndexT> -
using InsertableCollection = vrt::
collection:: Collection<ColT, IndexT> -
using CollectionIndexProxy = vrt::
collection:: CollectionProxy<ColT, IndexT> -
using CollectionProxy = vrt::
collection:: CollectionProxy<ColT, IndexT>
Functions
- void abort(std::string const str, int32_t const code)
- void output(std::string const str, int32_t const code, bool error, bool formatted, bool decorate, bool abort_out)
- auto rerror(char const* str) -> int
-
auto theCollective() -> collective::
CollectiveAlg* -
auto preconfigure(int& argc,
char**& argv) -> std::unique_ptr<arguments::
ArgvContainer> -
auto initializePreconfigured(MPI_Comm* comm,
arguments::
AppConfig const* appConfig, arguments:: ArgvContainer const* preconfigure_args) -> RuntimePtrType -
auto initialize(int& argc,
char**& argv,
MPI_Comm* comm,
arguments::
AppConfig const* appConfig) -> RuntimePtrType - auto initialize(MPI_Comm* comm) -> RuntimePtrType
-
auto initialize(int& argc,
char**& argv,
arguments::
AppConfig const* appConfig) -> RuntimePtrType -
auto initialize(arguments::
AppConfig const* appConfig) -> RuntimePtrType - void finalize(RuntimePtrType in_rt)
- void finalize()
-
auto theConfig() -> arguments::
AppConfig* - vt_declare_debug_scoped_modifiers(all)
- vt_declare_debug_scoped_modifiers(none)
- vt_declare_debug_scoped_modifiers(gen)
- vt_declare_debug_scoped_modifiers(runtime)
- vt_declare_debug_scoped_modifiers(active)
- vt_declare_debug_scoped_modifiers(term)
- vt_declare_debug_scoped_modifiers(termds)
- vt_declare_debug_scoped_modifiers(barrier)
- vt_declare_debug_scoped_modifiers(event)
- vt_declare_debug_scoped_modifiers(pipe)
- vt_declare_debug_scoped_modifiers(pool)
- vt_declare_debug_scoped_modifiers(reduce)
- vt_declare_debug_scoped_modifiers(rdma)
- vt_declare_debug_scoped_modifiers(rdma_channel)
- vt_declare_debug_scoped_modifiers(rdma_state)
- vt_declare_debug_scoped_modifiers(param)
- vt_declare_debug_scoped_modifiers(handler)
- vt_declare_debug_scoped_modifiers(hierlb)
- vt_declare_debug_scoped_modifiers(temperedlb)
- vt_declare_debug_scoped_modifiers(scatter)
- vt_declare_debug_scoped_modifiers(serial_msg)
- vt_declare_debug_scoped_modifiers(trace)
- vt_declare_debug_scoped_modifiers(location)
- vt_declare_debug_scoped_modifiers(lb)
- vt_declare_debug_scoped_modifiers(vrt)
- vt_declare_debug_scoped_modifiers(vrt_coll)
- vt_declare_debug_scoped_modifiers(worker)
- vt_declare_debug_scoped_modifiers(group)
- vt_declare_debug_scoped_modifiers(broadcast)
- vt_declare_debug_scoped_modifiers(objgroup)
- vt_declare_debug_scoped_modifiers(phase)
- vt_declare_debug_scoped_modifiers(context)
- vt_declare_debug_scoped_modifiers(epoch)
-
template<typename... Args>auto warningImpl(std::string const& str, ErrorCodeType error, bool quit, std::string const& file, int const line, std::string const& func, Args && ... args) -> std::enable_if_t<std::tuple_size<std::tuple<Args...>>::value !=0>
-
template<typename... Args>auto warningImpl(std::string const& str, ErrorCodeType error, bool quit, std::string const& file, int const line, std::string const& func, Args && ... args) -> std::enable_if_t<std::tuple_size<std::tuple<Args...>>::value==0>
-
template<typename Tuple, size_t... I>void warningImplTup(std::string const& str, ErrorCodeType error, bool quit, std::string const& file, int const line, std::string const& func, Tuple&& tup, std::index_sequence<I...>)
-
template<typename... Args>void warning(std::string const& str, ErrorCodeType error, bool quit, std::string const& file, int const line, std::string const& func, std::tuple<Args...>&& tup)
-
auto theContext() -> ctx::
Context* -
auto theEpoch() -> epoch::
EpochManip* -
auto theEvent() -> event::
AsyncEvent* -
auto theGroup() -> group::
GroupManager* -
auto theMsg() -> messaging::
ActiveMessenger* -
template<typename Env>auto envelopeGetEpoch(Env const& env) -> EpochType
- Get the epoch on an envelope; must be able to hold one.
-
template<typename Env>void envelopeSetEpoch(Env& env, EpochType const& epoch)
- Set the epoch on an envelope; must be able to hold one.
-
template<typename Env>auto envelopeGetTag(Env const& env) -> TagType
- Get the tag on an envelope; must be able to hold one.
-
template<typename Env>void envelopeSetTag(Env& env, TagType const& tag)
- Set the tag on an envelope; must be able to hold one.
- void envelopeInitEmpty(EpochEnvelope& env)
- Initialize an epoch envelope with default values.
- void envelopeInitEmpty(TagEnvelope& env)
- Initialize an tag envelope with default values.
- void envelopeInitEmpty(EpochTagEnvelope& env)
- Initialize an epoch and tag envelope with default values.
-
template<typename Env>auto envelopeGetHandler(Env const& env) -> HandlerType
- Get the handler on an envelope.
-
template<typename Env>auto envelopeGetDest(Env const& env) -> NodeType
- Get the destination node on an envelope.
-
template<typename Env>auto envelopeGetDeliverBcast(Env const& env) -> bool
- Check whether bcast should be delivered to sender.
-
template<typename Env>auto envelopeGetGroup(Env& env) -> GroupType
- Get the group on an envelope.
-
template<typename Env>auto envelopeGetRef(Env& env) -> RefType
- Get the reference count on an envelope.
-
template<typename Env>void envelopeRef(Env& env)
- Increase the reference count on an envelope.
-
template<typename Env>auto envelopeDeref(Env& env) -> RefType
- Decrement and get (sub-fetch) reference count on envelope.
-
template<typename Env>void setNormalType(Env& env)
- Clear all type bits make "normal".
-
template<typename Env>void setPipeType(Env& env)
- Set pipe bit
EnvPipe
. -
template<typename Env>void setPutType(Env& env)
- Set put bit
EnvPut
. -
template<typename Env>void setTermType(Env& env)
- Set term bit
EnvTerm
. -
template<typename Env>void setBroadcastType(Env& env, bool deliver_to_sender = true)
- Set broadcast bit (changes how
dest
is interpreted)EnvBroadcast
. -
template<typename Env>void setEpochType(Env& env)
- Set epoch bit
EnvEpoch
. -
template<typename Env>void setTagType(Env& env)
- Set tag bit
EnvTag
. -
template<typename Env>void envelopeSetHandler(Env& env, HandlerType const handler)
- Set handler field in envelope.
-
template<typename Env>void envelopeSetDest(Env& env, NodeType const& dest)
- Set destination
dest
field in envelope. -
template<typename Env>void envelopeSetRef(Env& env, RefType const& ref = 0)
- Set reference count on envelope.
-
template<typename Env>void envelopeSetGroup(Env& env, GroupType const& group = default_group)
- Set pipe bit
EnvPipe
. -
template<typename Env>void envelopeSetHasBeenSerialized(Env& env, bool has_been_serialized)
- Set whether this message's base serializer has been called.
-
template<typename Env>void envelopeSetCommLBDataRecordedAboveBareHandler(Env& env, bool comm_lb_data_recorded_above_bare_handler)
- Set whether this message shouldn't record bare handler communication data for LB.
-
template<typename Env>void envelopeSetIsLocked(Env& env, bool is_locked)
- Set whether this message's envelope is locked.
-
template<typename Env>void envelopeUnlockForForwarding(Env& env)
- Unlock an envelope, denoting the use is a proxy handler.
-
template<typename Env>void envelopeSetup(Env& env, NodeType const& dest, HandlerType const handler)
- Setup an envelope for the first time.
-
template<typename Env>void envelopeInit(Env& env)
- Initialize an envelope with default/sentinel values.
- void envelopeInitEmpty(Envelope& env)
- Initialize an envelope without defaults.
-
template<typename Env>void envelopeInitCopy(Env& env, Env const& src_env)
- Initialize an envelope via a copy.
-
template<typename Env>void envelopeCopyBcastData(Env& env, Env const& src_env)
- Copy broadcast related data.
-
template<typename Env>void envelopeInitRecv(Env& env)
- Initialize/validate an envelope that has been received.
- void envelopeInitEmpty(PutShortEnvelope& env)
- Initialize a
PutEnvelope
with extra put-related fields. -
template<typename Env>auto envelopeGetPutPtr(Env const& env) -> PutPtrType
- Get the put pointer.
-
template<typename Env>auto envelopeGetPutSize(Env const& env) -> PutEnvSizeType
- Get the put payload byte length.
-
template<typename Env>auto envelopeGetPutTag(Env const& env) -> TagType
- Get the put tag.
-
template<typename Env>void envelopeSetPutPtr(Env& env, PutPtrConstType ptr, PutEnvSizeType size)
- Set the put pointer and byte length for put.
-
template<typename Env>void envelopeSetPutPtrOnly(Env& env, PutPtrConstType ptr)
- Set the put pointer only.
-
template<typename Env>void envelopeSetPutTag(Env& env, TagType const& in_tag)
- Set the put tag.
-
template<typename Env>void setPackedPutType(Env& env)
- Set the envelope type bit for
EnvPackedPut
. -
template<typename Env>auto envelopeIsPackedPutType(Env const& env) -> bool
- Test if
EnvPackedPut
is set on the envelope. -
template<typename MsgT>void messageRef(MsgT* msg)
-
template<typename MsgT>void messageDeref(MsgT* msg)
-
template<typename MsgT, typename... Args>auto makeSharedMessage(Args && ... args) -> MsgT* deprecated
- Create a new 'raw' message.
-
template<typename MsgT, typename... Args>auto makeSharedMessageSz(std::size_t size, Args && ... args) -> MsgT* deprecated
- Create a new 'raw' message, of a given size.
-
template<typename MsgT, typename... Args>auto makeMessage(Args && ... args) -> MsgPtr<MsgT>
- Create a new message.
-
template<typename MsgT, typename... Args>auto makeMessageSz(std::size_t size, Args && ... args) -> MsgPtr<MsgT>
- Create a new message, of a size.
-
template<typename T>auto promoteMsgOwner(T*const msg) -> MsgPtr<T>
-
template<typename T>auto promoteMsg(MsgPtr<T> msg) -> MsgPtr<T>
-
template<typename T>auto promoteMsg(T* msg) -> MsgPtr<T>
- Wrap a message as a MsgPtr<Msg>, increasing ref-ownership.
-
auto theObjGroup() -> objgroup::
ObjGroupManager* -
auto thePhase() -> phase::
PhaseManager* -
auto theCB() -> pipe::
PipeManager* -
auto thePool() -> pool::
Pool* -
auto theRDMA() -> rdma::
RDMAManager* -
auto theHandleRDMA() -> rdma::
Manager* -
auto theVirtualManager() -> vrt::
VirtualContextManager* -
auto theSched() -> sched::
Scheduler* -
auto theTerm() -> term::
TerminationDetector* -
auto theLocMan() -> location::
LocationManager* - auto theCollection() -> CollectionManagerType*
-
auto theMemUsage() -> util::
memory:: MemoryUsage* - auto theNodeLBData() -> NodeLBDataType*
- auto theLBDataReader() -> LBDataRestartReaderType*
- auto theLBManager() -> LBManagerType*
- auto theTimeTrigger() -> TimeTriggerManagerType*
- void runSchedulerThrough(EpochType epoch)
-
template<typename Callable>void runInEpochRooted(Callable&& fn)
-
template<typename Callable>void runInEpochRooted(std::string const& label, Callable&& fn)
-
template<typename Callable>void runInEpochCollective(Callable&& fn)
-
template<typename Callable>void runInEpochCollective(std::string const& label, Callable&& fn)
-
template<typename Callable>void runInEpoch(EpochType ep, Callable&& fn)
-
template<typename ColT>auto makeCollection(const std::string& label = {}) -> vrt::
collection:: param:: ConstructParams<ColT> - Collectively construct a new collection with the parameter object builder.
-
template<typename ColT>auto makeCollectionRooted(const std::string& label = {}) -> vrt::
collection:: param:: ConstructParams<ColT> - Construct a new collection (from a single node) with the parameter object builder.
Variables
-
static runtime::
RuntimeInstType const collective_default_inst constexpr -
runtime::
Runtime* curRT - static NodeType const uninitialized_destination constexpr
- static PhysicalResourceType const no_workers constexpr
- static uint64_t const u64empty constexpr
- static uint32_t const u32empty constexpr
- static int64_t const s64empty constexpr
- static int32_t const s32empty constexpr
- static int const num_check_actions constexpr
- static TagType const no_tag constexpr
- static EventType const no_event constexpr
- static BarrierType const no_barrier constexpr
-
static RDMA_
HandleType const no_rdma_handle constexpr - static ByteType const no_byte constexpr
- static ByteType const no_offset constexpr
- static auto no_action constexpr
-
static RDMA_
PtrType const no_rdma_ptr constexpr - static VirtualProxyType const no_vrt_proxy constexpr
- static HandlerType const uninitialized_handler constexpr
-
static RDMA_
HandlerType const uninitialized_rdma_handler constexpr - static RefType const not_shared_message constexpr
-
static RDMA_
BlockType const no_rdma_block constexpr - static SeedType const no_seed constexpr
- static VirtualElmCountType const no_elms constexpr
- static TagType const local_rdma_op_tag constexpr
- static GroupType const no_group constexpr
- static GroupType const default_group constexpr
- static PhaseType const fst_lb_phase constexpr
- static PhaseType const no_lb_phase constexpr
- static PipeType const no_pipe constexpr
- static ObjGroupProxyType const no_obj_group constexpr
- static SequentialIDType const no_seq_id constexpr
- static SequentialIDType const first_seq_id constexpr
- static PriorityType const no_priority constexpr
- static PriorityLevelType const no_priority_level constexpr
- static ThreadIDType const no_thread_id constexpr
- static BitCountType const node_num_bits constexpr
- static BitCountType const handler_num_bits constexpr
- static BitCountType const ref_num_bits constexpr
- static BitCountType const epoch_num_bits constexpr
- static BitCountType const tag_num_bits constexpr
- static BitCountType const group_num_bits constexpr
- static BitCountType const priority_num_bits constexpr
- static BitCountType const priority_level_num_bits constexpr
- static EpochType const no_epoch constexpr
- The sentinel value for a empty epoch.
- HandlerType event_finished_han
- HandlerType check_event_finished_han
- static HandlerIdentifierType const first_handle_identifier constexpr
- static HandlerIdentifierType const uninitialized_handle_identifier constexpr
- static HandlerType const blank_handler constexpr
- static BitCountType const auto_num_bits constexpr
- static BitCountType const functor_num_bits constexpr
- static BitCountType const trace_num_bits constexpr
- static BitCountType const control_num_bits constexpr
- static BitCountType const base_msg_derived_num_bits constexpr
- static BitCountType const registry_type_bits constexpr
- static BitCountType const handler_id_num_bits constexpr
-
from_
s rdma_from -
to_
s rdma_to -
::vt::
runtime:: Runtime* rt -
static sched::
PriorityArrayType breadth_priority constexpr -
static sched::
PriorityArrayType medium_priority constexpr - static PriorityType const sys_max_priority constexpr
- static PriorityType const sys_min_priority constexpr
- static PriorityType const max_priority constexpr
- static PriorityType const min_priority constexpr
- static PriorityType const default_priority constexpr
Enum documentation
enum vt:: eHandlerBits
#include <src/vt/handler/handler.h>
Typedef documentation
using vt:: ActiveClosureFnType = std::function<void(vt:: BaseMessage*)>
#include <src/vt/activefn/activefn.h>
using vt:: ActiveFnType = void(vt:: BaseMessage*)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveFnPtrType = void(*)(vt:: BaseMessage*)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveVoidFnType = void()
#include <src/vt/activefn/activefn.h>
using vt:: ActiveTypedFnType = void(MessageT*)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveClosureRDMAGetFnType = std::function<RDMA_ GetType(vt:: BaseMessage*, ByteType, ByteType, TagType, bool)>
#include <src/vt/activefn/activefn.h>
using vt:: ActiveRDMAGetFnPtrType = RDMA_ GetType(*)(vt:: BaseMessage*, ByteType, ByteType, TagType, bool)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveTypedRDMAGetFnType = RDMA_ GetType(MessageT*, ByteType, ByteType, TagType, bool)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveClosureRDMAPutFnType = std::function<void(vt:: BaseMessage*, RDMA_ PtrType, ByteType, ByteType, TagType, bool)>
#include <src/vt/activefn/activefn.h>
using vt:: ActiveRDMAPutFnPtrType = void(*)(vt:: BaseMessage*, RDMA_ PtrType, ByteType, ByteType, TagType, bool)
#include <src/vt/activefn/activefn.h>
using vt:: ActiveTypedRDMAPutFnType = void(MessageT*, RDMA_ PtrType, ByteType, ByteType, TagType, bool)
#include <src/vt/activefn/activefn.h>
using vt:: CollectiveOps = CollectiveAnyOps<collective_default_inst>
#include <src/vt/collective/collective_ops.h>
using vt:: RDMA_PtrType = std::byte*
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_ElmType = uint64_t
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_BlockType = int64_t
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_HandleType = int64_t
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_HandlerType = int64_t
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_GetType = std::tuple<RDMA_ PtrType, ByteType>
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_PutRetType = RDMA_ GetType
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_ContinuationType = std::function<void(RDMA_ GetType)>
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_ContinuationDeleteType = std::function<void(RDMA_ GetType, ActionType)>
#include <src/vt/configs/types/types_rdma.h>
using vt:: RDMA_PutSerialize = std::function<RDMA_ PutRetType(RDMA_ PutRetType)>
#include <src/vt/configs/types/types_rdma.h>
using vt:: PhysicalResourceType = int16_t
#include <src/vt/configs/types/types_type.h>
using vt:: NodeType = PhysicalResourceType
#include <src/vt/configs/types/types_type.h>
Used to hold the current node/rank or the number of nodes.
using vt:: CoreType = PhysicalResourceType
#include <src/vt/configs/types/types_type.h>
Used to hold a core ID.
using vt:: HandlerType = int64_t
#include <src/vt/configs/types/types_type.h>
Used to hold a handler ID which identifier a function pointer/context.
using vt:: SeedType = int64_t
#include <src/vt/configs/types/types_type.h>
Used to hold a seed for random generation.
using vt:: EnvelopeDataType = int8_t
#include <src/vt/configs/types/types_type.h>
Used to hold the control bits in an envelope.
using vt:: EventType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to hold a local/remote event to wait for completion.
using vt:: SequentialIDType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to hold a sequential identifier for ordered/stateful operations.
using vt:: TagType = int32_t
#include <src/vt/configs/types/types_type.h>
Used to hold an tag, e.g., on messages or reduces.
using vt:: BarrierType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to identify a specific barrier.
using vt:: CollectiveAlgType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to identify a collective operation.
using vt:: RefType = uint16_t
#include <src/vt/configs/types/types_type.h>
Used to hold the reference count for messages.
using vt:: PipeRefType = int16_t
#include <src/vt/configs/types/types_type.h>
Used to hold the reference count for messages in pipes.
using vt:: ByteType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to store some number of bytes.
using vt:: BitCountType = int32_t
#include <src/vt/configs/types/types_type.h>
Used to store the number of bits in a field.
using vt:: SerialByteType = char
#include <src/vt/configs/types/types_type.h>
Used to store the number of bits for serialization.
using vt:: ErrorCodeType = int32_t
#include <src/vt/configs/types/types_type.h>
Used to store an error code.
using vt:: VirtualProxyType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to hold an identifier for a collection or other proxy.
using vt:: VirtualElmOnlyProxyType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to hold an identifier for an element in a collection.
using vt:: VirtualElmCountType = int64_t
#include <src/vt/configs/types/types_type.h>
Used to hold the count of elements in a collection.
using vt:: UniqueIndexBitType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used for mapping between index to contiguous bits.
using vt:: GroupType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used for hold an identifier for a group.
using vt:: MsgSizeType = int64_t
#include <src/vt/configs/types/types_type.h>
Used for hold the size of a message.
using vt:: PhaseType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used for hold a phase for load balancing.
using vt:: LoadType = double
#include <src/vt/configs/types/types_type.h>
LoadType used for load balancing.
using vt:: SubphaseType = uint16_t
#include <src/vt/configs/types/types_type.h>
Used for hold a sub-phase for load balancing.
using vt:: PipeType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used for hold the identifier for a pipe (callbacks)
using vt:: ObjGroupProxyType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used for hold the proxy ID for an objgroup.
using vt:: PriorityType = uint16_t
#include <src/vt/configs/types/types_type.h>
Used for hold the priority of a message.
using vt:: PriorityLevelType = uint8_t
#include <src/vt/configs/types/types_type.h>
Used for hold the level for a priority of a message.
using vt:: ComponentIDType = uint32_t
#include <src/vt/configs/types/types_type.h>
Used for hold a unique ID for each component.
using vt:: ThreadIDType = uint64_t
#include <src/vt/configs/types/types_type.h>
Used to hold a unique ID for a user-level thread on a particular node.
using vt:: ActionType = std::function<void()>
#include <src/vt/configs/types/types_type.h>
Used for generically store an action to perform.
using vt:: ActionProxyType = std::function<void(VirtualProxyType)>
#include <src/vt/configs/types/types_type.h>
Used for generically store an action that requires a proxy.
using vt:: ActionNodeType = std::function<void(NodeType)>
#include <src/vt/configs/types/types_type.h>
Used for generically store an action that requires a node.
using vt:: EpochType = epoch:: EpochType
#include <src/vt/epoch/epoch_type.h>
The strong epoch type for holding a epoch for termination detection.
using vt:: EventRecordType = event:: EventRecord
#include <src/vt/event/event.h>
using vt:: HandlerIdentifierType = uint64_t
#include <src/vt/handler/handler.h>
using vt:: HandlerControlType = uint32_t
#include <src/vt/handler/handler.h>
using vt:: PtrLenPairType = std::tuple<std::byte*, ByteType>
#include <src/vt/messaging/active.h>
A pair of a std::byte* and number of bytes (length) for sending data.
using vt:: ContinuationDeleterType = std::function<void(PtrLenPairType data, ActionType deleter)>
#include <src/vt/messaging/active.h>
A continuation function with an allocated pointer with a deleter function.
using vt:: Node = Strong<NodeType, uninitialized_destination, StrongNodeType>
#include <src/vt/messaging/active.h>
using vt:: Active = messaging:: ActiveMessenger
#include <src/vt/messaging/active.h>
using vt:: Envelope = messaging:: ActiveEnvelope
using vt:: EpochEnvelope = messaging:: EpochActiveEnvelope
using vt:: TagEnvelope = messaging:: TagActiveEnvelope
typedef messaging:: eEnvelopeType vt:: eEnvType
using vt:: PutPtrType = std::byte*
using vt:: PutPtrConstType = std::byte const *
using vt:: PutEnvSizeType = size_t
using vt:: PutUnderEnvelopeT = EpochTagEnvelope
using vt:: PutShortEnvelope = PutEnvelope<EpochTagEnvelope, size_t>
using vt:: BaseMessage = messaging:: BaseMsg
#include <src/vt/messaging/message/message.h>
Alias to the base of all messages.
using vt:: ActiveMessage = messaging:: ActiveMsg<EnvelopeT>
#include <src/vt/messaging/message/message.h>
Alias to the a message with any envelope.
using vt:: ShortMessage = messaging:: ActiveMsg<Envelope>
#include <src/vt/messaging/message/message.h>
Alias to the shortest message available with no epoch or tag allowed.
using vt:: EpochMessage = messaging:: ActiveMsg<EpochEnvelope>
#include <src/vt/messaging/message/message.h>
Alias to a message with only an epoch.
using vt:: EpochTagMessage = messaging:: ActiveMsg<EpochTagEnvelope>
#include <src/vt/messaging/message/message.h>
Alias to a message with an epoch and tag.
using vt:: Message = EpochTagMessage
#include <src/vt/messaging/message/message.h>
Alias to the default message (with an epoch and tag)
using vt:: BaseMsgType = ShortMessage
#include <src/vt/messaging/message/message.h>
using vt:: NonSerialized = vt:: messaging:: NonSerializedMsg<MsgT, SelfT>
using vt:: SerializeSupported = vt:: messaging:: SerializeSupportedMsg<MsgT, SelfT>
using vt:: SerializeRequired = vt:: messaging:: SerializeRequiredMsg<MsgT, SelfT>
using vt:: SerializeIfNeeded = vt:: messaging:: SerializeIfNeededMsg<MsgT, SelfT, DepTypesT...>
using vt:: MsgVirtualPtr = messaging:: MsgSharedPtr<T>
Use MsgPtr<T>
, for which this is an alias.
using vt:: MsgVirtualPtrAny = messaging:: MsgSharedPtr<ShortMessage>
Use MsgPtr<ShortMessage>
, or as appropriate.
using vt:: MsgSharedPtr = messaging:: MsgSharedPtr<T>
Use MsgPtr<T>
, for which this is an alias.
using vt:: MsgPtr = messaging:: MsgSharedPtr<T>
Wrapper to manage Active Messages.
A MsgPtr represents a 'shared pointer like' object wrapping a message that correctly manages reference-counts to order to eliminate memory leaks.
using vt:: Callback = pipe:: callback:: cbunion:: CallbackTyped<Args...>
using vt:: RDMA_TargetType = rdma:: Target
#include <src/vt/rdma/rdma_types.h>
using vt:: RDMA_NonTargetType = rdma:: NonTarget
#include <src/vt/rdma/rdma_types.h>
using vt:: HandleRDMA = rdma:: Handle<T, rdma:: HandleEnum:: StaticSize, I>
#include <src/vt/rdmahandle/handle.h>
using vt:: Lock = rdma:: Lock
#include <src/vt/rdmahandle/lock_mpi.h>
using vt:: CollectionManagerType = vrt:: collection:: CollectionManager
#include <src/vt/runtime/runtime_get.cc>
using vt:: NodeLBDataType = vrt:: collection:: balance:: NodeLBData
#include <src/vt/runtime/runtime_get.cc>
using vt:: LBManagerType = vrt:: collection:: balance:: LBManager
#include <src/vt/runtime/runtime_get.cc>
using vt:: TimeTriggerManagerType = timetrigger:: TimeTriggerManager
#include <src/vt/runtime/runtime_get.cc>
using vt:: RuntimeType = runtime:: RuntimeHolderType
#include <src/vt/runtime/runtime_headers.h>
using vt:: RuntimeUnsafePtrType = runtime:: RuntimeHolderUnsafePtrType
#include <src/vt/runtime/runtime_headers.h>
using vt:: RuntimePtrType = RuntimeType
#include <src/vt/runtime/runtime_headers.h>
using vt:: IntegralSet = term:: interval:: IntegralSetBase<DomainT, DomainT{}, std::allocator, term:: interval:: Interval, std::set, IntervalCompare>
using vt:: IntervalCompare = term:: interval:: IntervalCompare<DomainT>
using vt:: Interval = term:: interval:: Interval<DomainT>
using vt:: StrongIntegralSet = term:: interval:: StrongIntegralSet<T>
using vt:: TimeType = TimeTypeWrapper
#include <src/vt/timing/timing_type.h>
using vt:: DenseIndex = index:: DenseIndexArray<IndexType, ndim>
#include <src/vt/topos/index/index.h>
using vt:: IdxBase = index:: IdxBase
#include <src/vt/topos/index/index.h>
using vt:: Index1D = index:: Index1D<index:: IdxBase>
#include <src/vt/topos/index/index.h>
using vt:: Index2D = index:: Index2D<index:: IdxBase>
#include <src/vt/topos/index/index.h>
using vt:: Index3D = index:: Index3D<index:: IdxBase>
#include <src/vt/topos/index/index.h>
using vt:: IndexND = index:: IdxType<index:: IdxBase, N>
#include <src/vt/topos/index/index.h>
using vt:: IdxType = index:: IdxType<T, N>
#include <src/vt/topos/index/index.h>
using vt:: IdxType1D = index:: Index1D<T>
#include <src/vt/topos/index/index.h>
using vt:: IdxType2D = index:: Index2D<T>
#include <src/vt/topos/index/index.h>
using vt:: IdxType3D = index:: Index3D<T>
#include <src/vt/topos/index/index.h>
using vt:: LocationRoutedMsg = location:: EntityMsg<EntityID, ActiveMessageT>
using vt:: BitCounterType = utils:: BitCounter<T>
#include <src/vt/utils/bits/bits_common.h>
typedef utils:: BitPacker vt:: BitPackerType
#include <src/vt/utils/bits/bits_common.h>
using vt:: NoMsg = util:: fntraits:: detail:: NoMsg
#include <src/vt/utils/fntraits/fntraits.h>
using vt:: Strong = util:: strong:: detail:: Strong<T, init_val, Tag>
#include <src/vt/utils/strong/strong_type.h>
Type-alias for strong types.
using vt:: CollectionMessage = vrt:: collection:: CollectionMessage<ColT, MsgT>
using vt:: Collection = vrt:: collection:: Collection<ColT, IndexT>
using vt:: InsertableCollection = vrt:: collection:: Collection<ColT, IndexT>
using vt:: CollectionIndexProxy = vrt:: collection:: CollectionProxy<ColT, IndexT>
using vt:: CollectionProxy = vrt:: collection:: CollectionProxy<ColT, IndexT>
Function documentation
void vt:: abort(std::string const str,
int32_t const code)
#include <src/vt/collective/basic.cc>
void vt:: output(std::string const str,
int32_t const code,
bool error,
bool formatted,
bool decorate,
bool abort_out)
#include <src/vt/collective/basic.cc>
int vt:: rerror(char const* str)
#include <src/vt/collective/basic.cc>
std::unique_ptr<arguments:: ArgvContainer> vt:: preconfigure(int& argc,
char**& argv)
#include <src/vt/collective/startup.cc>
RuntimePtrType vt:: initializePreconfigured(MPI_Comm* comm,
arguments:: AppConfig const* appConfig,
arguments:: ArgvContainer const* preconfigure_args)
#include <src/vt/collective/startup.cc>
RuntimePtrType vt:: initialize(int& argc,
char**& argv,
MPI_Comm* comm,
arguments:: AppConfig const* appConfig)
#include <src/vt/collective/startup.cc>
RuntimePtrType vt:: initialize(MPI_Comm* comm)
#include <src/vt/collective/startup.cc>
RuntimePtrType vt:: initialize(int& argc,
char**& argv,
arguments:: AppConfig const* appConfig)
#include <src/vt/collective/startup.cc>
RuntimePtrType vt:: initialize(arguments:: AppConfig const* appConfig)
#include <src/vt/collective/startup.cc>
void vt:: finalize(RuntimePtrType in_rt)
#include <src/vt/collective/startup.cc>
void vt:: finalize()
#include <src/vt/collective/startup.cc>
arguments:: AppConfig* vt:: theConfig()
vt:: vt_declare_debug_scoped_modifiers(all)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(none)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(gen)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(runtime)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(active)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(term)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(termds)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(barrier)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(event)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(pipe)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(pool)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(reduce)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(rdma)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(rdma_channel)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(rdma_state)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(param)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(handler)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(hierlb)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(temperedlb)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(scatter)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(serial_msg)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(trace)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(location)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(lb)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(vrt)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(vrt_coll)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(worker)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(group)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(broadcast)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(objgroup)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(phase)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(context)
#include <src/vt/configs/debug/debug_print.h>
vt:: vt_declare_debug_scoped_modifiers(epoch)
#include <src/vt/configs/debug/debug_print.h>
#include <src/vt/configs/error/soft_error.h>
template<typename... Args>
std::enable_if_t<std::tuple_size<std::tuple<Args...>>::value !=0> vt:: warningImpl(std::string const& str,
ErrorCodeType error,
bool quit,
std::string const& file,
int const line,
std::string const& func,
Args && ... args)
#include <src/vt/configs/error/soft_error.h>
template<typename... Args>
std::enable_if_t<std::tuple_size<std::tuple<Args...>>::value==0> vt:: warningImpl(std::string const& str,
ErrorCodeType error,
bool quit,
std::string const& file,
int const line,
std::string const& func,
Args && ... args)
#include <src/vt/configs/error/soft_error.h>
template<typename Tuple, size_t... I>
void vt:: warningImplTup(std::string const& str,
ErrorCodeType error,
bool quit,
std::string const& file,
int const line,
std::string const& func,
Tuple&& tup,
std::index_sequence<I...>)
#include <src/vt/configs/error/soft_error.h>
template<typename... Args>
void vt:: warning(std::string const& str,
ErrorCodeType error,
bool quit,
std::string const& file,
int const line,
std::string const& func,
std::tuple<Args...>&& tup)
ctx:: Context* vt:: theContext()
#include <src/vt/context/context.h>
epoch:: EpochManip* vt:: theEpoch()
#include <src/vt/epoch/epoch_manip.h>
event:: AsyncEvent* vt:: theEvent()
#include <src/vt/event/event.h>
group:: GroupManager* vt:: theGroup()
#include <src/vt/group/group_manager.h>
messaging:: ActiveMessenger* vt:: theMsg()
#include <src/vt/messaging/active.h>
template<typename Env>
EpochType vt:: envelopeGetEpoch(Env const& env)
Get the epoch on an envelope; must be able to hold one.
Parameters | |
---|---|
env in/out | the envelope |
Returns | the epoch in the envelope |
template<typename Env>
void vt:: envelopeSetEpoch(Env& env,
EpochType const& epoch)
Set the epoch on an envelope; must be able to hold one.
Parameters | |
---|---|
env in/out | the envelope |
epoch in | epoch to set |
template<typename Env>
TagType vt:: envelopeGetTag(Env const& env)
Get the tag on an envelope; must be able to hold one.
Parameters | |
---|---|
env in/out | the envelope |
Returns | the tag in the envelope |
template<typename Env>
void vt:: envelopeSetTag(Env& env,
TagType const& tag)
Set the tag on an envelope; must be able to hold one.
Parameters | |
---|---|
env in/out | the envelope |
tag in | tag to set |
void vt:: envelopeInitEmpty(EpochEnvelope& env)
Initialize an epoch envelope with default values.
Parameters | |
---|---|
env in/out | the envelope |
void vt:: envelopeInitEmpty(TagEnvelope& env)
Initialize an tag envelope with default values.
Parameters | |
---|---|
env in/out | the envelope |
void vt:: envelopeInitEmpty(EpochTagEnvelope& env)
Initialize an epoch and tag envelope with default values.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
HandlerType vt:: envelopeGetHandler(Env const& env)
Get the handler on an envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | the handler in the envelope |
template<typename Env>
NodeType vt:: envelopeGetDest(Env const& env)
Get the destination node on an envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | the destination node in the envelope |
template<typename Env>
bool vt:: envelopeGetDeliverBcast(Env const& env)
Check whether bcast should be delivered to sender.
Parameters | |
---|---|
env in | the envelope |
Returns | whether to deliver msg to sender |
template<typename Env>
GroupType vt:: envelopeGetGroup(Env& env)
Get the group on an envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | the group in the envelope |
template<typename Env>
RefType vt:: envelopeGetRef(Env& env)
Get the reference count on an envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | the reference count in the envelope |
template<typename Env>
void vt:: envelopeRef(Env& env)
Increase the reference count on an envelope.
Parameters | |
---|---|
env in | the envelope |
template<typename Env>
RefType vt:: envelopeDeref(Env& env)
Decrement and get (sub-fetch) reference count on envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | the new reference count after decrement |
template<typename Env>
void vt:: setNormalType(Env& env)
Clear all type bits make "normal".
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
void vt:: setPipeType(Env& env)
Set pipe bit EnvPipe
.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
void vt:: setPutType(Env& env)
Set put bit EnvPut
.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
void vt:: setTermType(Env& env)
Set term bit EnvTerm
.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
void vt:: setBroadcastType(Env& env,
bool deliver_to_sender = true)
Set broadcast bit (changes how dest
is interpreted) EnvBroadcast
.
Parameters | |
---|---|
env in/out | the envelope |
deliver_to_sender in | whether the message should be delivered to sender |
template<typename Env>
void vt:: setEpochType(Env& env)
Set epoch bit EnvEpoch
.
Parameters | |
---|---|
env in/out | the envelope |
Indicates that the envelope is either of type EpochActiveEnvelope
or EpochTagActiveEnvelope
depending on whether EnvTag
is set or not.
template<typename Env>
void vt:: setTagType(Env& env)
Set tag bit EnvTag
.
Parameters | |
---|---|
env in/out | the envelope |
Indicates that the envelope is either of type TagActiveEnvelope
or EpochTagActiveEnvelope
depending on whether EnvEpoch
is set or not.
template<typename Env>
void vt:: envelopeSetHandler(Env& env,
HandlerType const handler)
Set handler field in envelope.
Parameters | |
---|---|
env in/out | the envelope |
handler in | the handler |
template<typename Env>
void vt:: envelopeSetDest(Env& env,
NodeType const& dest)
Set destination dest
field in envelope.
Parameters | |
---|---|
env in/out | the envelope |
dest in | the destination if set or root if (non-group) broadcast |
template<typename Env>
void vt:: envelopeSetRef(Env& env,
RefType const& ref = 0)
Set reference count on envelope.
Parameters | |
---|---|
env in/out | the envelope |
ref in | the reference count |
This overrides the typical mechanism for (de-)referencing May be dangerous to set directly. Typically you should use this in special cases when the current reference count does not apply. For instance, when a message arrives off the network and the count needs to be reset.
template<typename Env>
void vt:: envelopeSetGroup(Env& env,
GroupType const& group = default_group)
Set pipe bit EnvPipe
.
Parameters | |
---|---|
env in/out | the envelope |
group |
template<typename Env>
void vt:: envelopeSetHasBeenSerialized(Env& env,
bool has_been_serialized)
Set whether this message's base serializer has been called.
Parameters | |
---|---|
env in/out | the envelope |
has_been_serialized in | value indicating message is serialized |
template<typename Env>
void vt:: envelopeSetCommLBDataRecordedAboveBareHandler(Env& env,
bool comm_lb_data_recorded_above_bare_handler)
Set whether this message shouldn't record bare handler communication data for LB.
Parameters | |
---|---|
env in/out | the envelope |
comm_lb_data_recorded_above_bare_handler in | value indicating message shouldn't record bare handler LB data |
template<typename Env>
void vt:: envelopeSetIsLocked(Env& env,
bool is_locked)
Set whether this message's envelope is locked.
Parameters | |
---|---|
env in/out | the envelope |
is_locked in | value indicating if message is locked |
A locked message will prevent key parts of the envelope from being updated with a guard assert. This is to prevent accidental edge-cases such as sending a message twice.
A message is locked when it is sent and received. Unlocking messages should be reserved for special cases as done in some core code.
template<typename Env>
void vt:: envelopeUnlockForForwarding(Env& env)
Unlock an envelope, denoting the use is a proxy handler.
Parameters | |
---|---|
env in/out | the envelope |
A received message is normally locked to discourage the re-usage of messages supplied to handlers. However, some proxy/forwarding handlers re-use the original message.
This is equivalent to calling envelopeSetIsLocked
with false and should generally be set inside the message handler itself.
template<typename Env>
void vt:: envelopeSetup(Env& env,
NodeType const& dest,
HandlerType const handler)
Setup an envelope for the first time.
Parameters | |
---|---|
env in/out | the envelope |
dest in | the destination node |
handler in | the handler |
template<typename Env>
void vt:: envelopeInit(Env& env)
Initialize an envelope with default/sentinel values.
Parameters | |
---|---|
env in/out | the envelope |
void vt:: envelopeInitEmpty(Envelope& env)
Initialize an envelope without defaults.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
void vt:: envelopeInitCopy(Env& env,
Env const& src_env)
Initialize an envelope via a copy.
Parameters | |
---|---|
env in | the original envelope to use as a copy |
src_env |
Some properties of the target envelope are preserved. The target envelope is left unlocked.
template<typename Env>
void vt:: envelopeCopyBcastData(Env& env,
Env const& src_env)
Copy broadcast related data.
Parameters | |
---|---|
env in | the original envelope to use as a copy |
src_env |
template<typename Env>
void vt:: envelopeInitRecv(Env& env)
Initialize/validate an envelope that has been received.
Parameters | |
---|---|
env in/out | the envelope |
The ref-count is set to zero.
void vt:: envelopeInitEmpty(PutShortEnvelope& env)
Initialize a PutEnvelope
with extra put-related fields.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
PutPtrType vt:: envelopeGetPutPtr(Env const& env)
Get the put pointer.
Parameters | |
---|---|
env in | the envelope |
Returns | the put pointer |
template<typename Env>
PutEnvSizeType vt:: envelopeGetPutSize(Env const& env)
Get the put payload byte length.
Parameters | |
---|---|
env in | the envelope |
Returns | the put length |
template<typename Env>
TagType vt:: envelopeGetPutTag(Env const& env)
Get the put tag.
Parameters | |
---|---|
env in | the envelope |
Returns | the put tag |
template<typename Env>
void vt:: envelopeSetPutPtr(Env& env,
PutPtrConstType ptr,
PutEnvSizeType size)
Set the put pointer and byte length for put.
Parameters | |
---|---|
env in/out | the envelope |
ptr in | the put pointer |
size in | the put byte length |
template<typename Env>
void vt:: envelopeSetPutPtrOnly(Env& env,
PutPtrConstType ptr)
Set the put pointer only.
Parameters | |
---|---|
env in/out | the envelope |
ptr in | the put pointer |
template<typename Env>
void vt:: envelopeSetPutTag(Env& env,
TagType const& in_tag)
Set the put tag.
Parameters | |
---|---|
env in/out | the envelope |
in_tag in | the put tag |
template<typename Env>
void vt:: setPackedPutType(Env& env)
Set the envelope type bit for EnvPackedPut
.
Parameters | |
---|---|
env in/out | the envelope |
template<typename Env>
bool vt:: envelopeIsPackedPutType(Env const& env)
Test if EnvPackedPut
is set on the envelope.
Parameters | |
---|---|
env in | the envelope |
Returns | whether the bit is set |
#include <src/vt/messaging/message/refs.h>
template<typename MsgT>
void vt:: messageRef(MsgT* msg)
#include <src/vt/messaging/message/refs.h>
template<typename MsgT>
void vt:: messageDeref(MsgT* msg)
template<typename MsgT, typename... Args>
MsgT* vt:: makeSharedMessage(Args && ... args)
Create a new 'raw' message.
Parameters | |
---|---|
args in | forwarded message arguments for constructor |
Returns | a bare message pointer |
Create a new message and initialize internal state. The arguments are forwarded down to the underlying message's constructor.
template<typename MsgT, typename... Args>
MsgT* vt:: makeSharedMessageSz(std::size_t size,
Args && ... args)
Create a new 'raw' message, of a given size.
Parameters | |
---|---|
size in | extra requested size at the end of message |
args in | forwarded message arguments for constructor |
Returns | a bare message pointer |
Create a new message and initialize internal state. The arguments are forwarded down to the underlying message's constructor.
template<typename MsgT, typename... Args>
MsgPtr<MsgT> vt:: makeMessage(Args && ... args)
Create a new message.
Parameters | |
---|---|
args in | forwarded message arguments for constructor |
Returns | a shared message pointer |
Create a new message already wrapped in a MsgPtr. The arguments are forwarded down to the underlying message's constructor.
The lifetime of the message is controlled by MsgPtr and will be destroyed when the returned MsgPtr (and all copies of such) are destroyed.
template<typename MsgT, typename... Args>
MsgPtr<MsgT> vt:: makeMessageSz(std::size_t size,
Args && ... args)
Create a new message, of a size.
Parameters | |
---|---|
size in | extra requested size at the end of message |
args in | forwarded message arguments for constructor |
Returns | a shared message pointer |
Create a new message already wrapped in a MsgPtr. The arguments are forwarded down to the underlying message's constructor.
The lifetime of the message is controlled by MsgPtr and will be destroyed when the returned MsgPtr (and all copies of such) are destroyed.
template<typename T>
MsgPtr<T> vt:: promoteMsgOwner(T*const msg)
Obsolete form - do not use. There is no direct replacement; has_owner_ is removed.
template<typename T>
MsgPtr<T> vt:: promoteMsg(MsgPtr<T> msg)
Obsolete form - do not use. There is no direct replacement; has_owner_ is removed and the semantic operation differed from promoteMsg(T*).
template<typename T>
MsgPtr<T> vt:: promoteMsg(T* msg)
Wrap a message as a MsgPtr<Msg>, increasing ref-ownership.
This is the same as using MsgPtr<T>{T*} directly. The primary usage is in historic call-sites as new code should prefer using makeMessage
(and accepting a MsgPtr) instead of creating a raw message first.
objgroup:: ObjGroupManager* vt:: theObjGroup()
#include <src/vt/objgroup/manager.fwd.h>
phase:: PhaseManager* vt:: thePhase()
#include <src/vt/phase/phase_manager.h>
pipe:: PipeManager* vt:: theCB()
#include <src/vt/pipe/pipe_manager.fwd.h>
pool:: Pool* vt:: thePool()
#include <src/vt/pool/pool.h>
rdma:: RDMAManager* vt:: theRDMA()
#include <src/vt/rdma/rdma.h>
rdma:: Manager* vt:: theHandleRDMA()
#include <src/vt/rdmahandle/manager.fwd.h>
sched:: Scheduler* vt:: theSched()
#include <src/vt/runtime/runtime_get.cc>
term:: TerminationDetector* vt:: theTerm()
#include <src/vt/runtime/runtime_get.cc>
location:: LocationManager* vt:: theLocMan()
#include <src/vt/runtime/runtime_get.cc>
CollectionManagerType* vt:: theCollection()
#include <src/vt/runtime/runtime_get.cc>
util:: memory:: MemoryUsage* vt:: theMemUsage()
#include <src/vt/runtime/runtime_get.cc>
NodeLBDataType* vt:: theNodeLBData()
#include <src/vt/runtime/runtime_get.cc>
LBDataRestartReaderType* vt:: theLBDataReader()
#include <src/vt/runtime/runtime_get.cc>
LBManagerType* vt:: theLBManager()
#include <src/vt/runtime/runtime_get.cc>
TimeTriggerManagerType* vt:: theTimeTrigger()
#include <src/vt/runtime/runtime_get.cc>
void vt:: runSchedulerThrough(EpochType epoch)
#include <src/vt/scheduler/scheduler.cc>
#include <src/vt/scheduler/scheduler.h>
template<typename Callable>
void vt:: runInEpochRooted(Callable&& fn)
#include <src/vt/scheduler/scheduler.h>
template<typename Callable>
void vt:: runInEpochRooted(std::string const& label,
Callable&& fn)
#include <src/vt/scheduler/scheduler.h>
template<typename Callable>
void vt:: runInEpochCollective(Callable&& fn)
#include <src/vt/scheduler/scheduler.h>
template<typename Callable>
void vt:: runInEpochCollective(std::string const& label,
Callable&& fn)
#include <src/vt/scheduler/scheduler.impl.h>
template<typename Callable>
void vt:: runInEpoch(EpochType ep,
Callable&& fn)
template<typename ColT>
vrt:: collection:: param:: ConstructParams<ColT> vt:: makeCollection(const std::string& label = {})
Collectively construct a new collection with the parameter object builder.
Parameters | |
---|---|
label in | collection label |
Returns | the parameter configuration object |
template<typename ColT>
vrt:: collection:: param:: ConstructParams<ColT> vt:: makeCollectionRooted(const std::string& label = {})
Construct a new collection (from a single node) with the parameter object builder.
Parameters | |
---|---|
label in | collection label |
Returns | the parameter configuration object |
Variable documentation
static runtime:: RuntimeInstType const vt:: collective_default_inst constexpr
#include <src/vt/collective/collective_ops.h>
runtime:: Runtime* vt:: curRT
#include <src/vt/configs/debug/debug_print.h>
static NodeType const vt:: uninitialized_destination constexpr
static PhysicalResourceType const vt:: no_workers constexpr
static uint64_t const vt:: u64empty constexpr
static uint32_t const vt:: u32empty constexpr
static int64_t const vt:: s64empty constexpr
static int32_t const vt:: s32empty constexpr
static int const vt:: num_check_actions constexpr
static BarrierType const vt:: no_barrier constexpr
static RDMA_ HandleType const vt:: no_rdma_handle constexpr
static auto vt:: no_action constexpr
static RDMA_ PtrType const vt:: no_rdma_ptr constexpr
static VirtualProxyType const vt:: no_vrt_proxy constexpr
static HandlerType const vt:: uninitialized_handler constexpr
static RDMA_ HandlerType const vt:: uninitialized_rdma_handler constexpr
static RefType const vt:: not_shared_message constexpr
static RDMA_ BlockType const vt:: no_rdma_block constexpr
static VirtualElmCountType const vt:: no_elms constexpr
static TagType const vt:: local_rdma_op_tag constexpr
static GroupType const vt:: default_group constexpr
static PhaseType const vt:: fst_lb_phase constexpr
static PhaseType const vt:: no_lb_phase constexpr
static ObjGroupProxyType const vt:: no_obj_group constexpr
static SequentialIDType const vt:: no_seq_id constexpr
static SequentialIDType const vt:: first_seq_id constexpr
static PriorityType const vt:: no_priority constexpr
static PriorityLevelType const vt:: no_priority_level constexpr
static ThreadIDType const vt:: no_thread_id constexpr
static BitCountType const vt:: node_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: handler_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: ref_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: epoch_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: tag_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: group_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: priority_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static BitCountType const vt:: priority_level_num_bits constexpr
#include <src/vt/configs/types/types_size.h>
static EpochType const vt:: no_epoch constexpr
#include <src/vt/epoch/epoch_type.h>
The sentinel value for a empty epoch.
HandlerType vt:: event_finished_han
#include <src/vt/event/event_msgs.h>
static HandlerIdentifierType const vt:: first_handle_identifier constexpr
#include <src/vt/handler/handler.h>
static HandlerIdentifierType const vt:: uninitialized_handle_identifier constexpr
#include <src/vt/handler/handler.h>
static HandlerType const vt:: blank_handler constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: auto_num_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: functor_num_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: trace_num_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: control_num_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: base_msg_derived_num_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: registry_type_bits constexpr
#include <src/vt/handler/handler.h>
static BitCountType const vt:: handler_id_num_bits constexpr
#include <src/vt/handler/handler.h>
from_ s vt:: rdma_from
#include <src/vt/rdma/rdma_types.cc>
to_ s vt:: rdma_to
#include <src/vt/rdma/rdma_types.cc>
::vt:: runtime:: Runtime* vt:: rt
#include <src/vt/runtime/runtime_inst.cc>
static sched:: PriorityArrayType vt:: breadth_priority constexpr
#include <src/vt/scheduler/priority.h>
static sched:: PriorityArrayType vt:: medium_priority constexpr
#include <src/vt/scheduler/priority.h>
static PriorityType const vt:: sys_max_priority constexpr
#include <src/vt/scheduler/priority.h>
static PriorityType const vt:: sys_min_priority constexpr
#include <src/vt/scheduler/priority.h>
static PriorityType const vt:: max_priority constexpr
#include <src/vt/scheduler/priority.h>
static PriorityType const vt:: min_priority constexpr
#include <src/vt/scheduler/priority.h>
static PriorityType const vt:: default_priority constexpr
#include <src/vt/scheduler/priority.h>