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 metrics
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::RuntimeInstType instance = collective_default_inst>
struct CollectiveAnyOps
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()
template<typename MessageT>
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)
template<typename MessageT>
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)
template<typename MessageT>
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 SharedIDType = int
Used to hold a shared ID.
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.
template<typename EnvelopeT>
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
template<typename MsgT, typename SelfT>
using NonSerialized = vt::messaging::NonSerializedMsg<MsgT, SelfT>
template<typename MsgT, typename SelfT>
using SerializeSupported = vt::messaging::SerializeSupportedMsg<MsgT, SelfT>
template<typename MsgT, typename SelfT>
using SerializeRequired = vt::messaging::SerializeRequiredMsg<MsgT, SelfT>
template<typename MsgT, typename SelfT, typename ... DepTypesT>
using SerializeIfNeeded = vt::messaging::SerializeIfNeededMsg<MsgT, SelfT, DepTypesT...>
using PayloadMessage = messaging::PutMessageComponent<ActiveMessage<PutShortEnvelope>>
template<typename T>
using MsgVirtualPtr = messaging::MsgSharedPtr<T>
using MsgVirtualPtrAny = messaging::MsgSharedPtr<ShortMessage>
template<typename T>
using MsgSharedPtr = messaging::MsgSharedPtr<T>
template<typename T>
using MsgPtr = messaging::MsgSharedPtr<T>
Wrapper to manage Active Messages.
template<typename... Args>
using Callback = pipe::callback::cbunion::CallbackTyped<Args...>
using CallbackU = pipe::callback::cbunion::CallbackRawBaseSingle
using RDMA_TargetType = rdma::Target
using RDMA_NonTargetType = rdma::NonTarget
template<typename T, typename I = vt::NodeType>
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
template<typename DomainT>
using IntegralSet = term::interval::IntegralSetBase<DomainT, DomainT{}, std::allocator, term::interval::Interval, std::set, IntervalCompare>
template<typename DomainT>
using IntervalCompare = term::interval::IntervalCompare<DomainT>
template<typename DomainT>
using Interval = term::interval::Interval<DomainT>
template<typename T>
using StrongIntegralSet = term::interval::StrongIntegralSet<T>
using TimeType = TimeTypeWrapper
template<typename IndexType, index::NumDimensionsType ndim>
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 Index4D = index::Index4D<index::IdxBase>
using Index5D = index::Index5D<index::IdxBase>
using Index6D = index::Index6D<index::IdxBase>
template<int8_t N>
using IndexND = index::IdxType<index::IdxBase, N>
template<typename T, int8_t N>
using IdxType = index::IdxType<T, N>
template<typename T>
using IdxType1D = index::Index1D<T>
template<typename T>
using IdxType2D = index::Index2D<T>
template<typename T>
using IdxType3D = index::Index3D<T>
template<typename T>
using IdxType4D = index::Index4D<T>
template<typename T>
using IdxType5D = index::Index5D<T>
template<typename T>
using IdxType6D = index::Index6D<T>
template<typename EntityID, typename ActiveMessageT>
using LocationRoutedMsg = location::EntityMsg<EntityID, ActiveMessageT>
template<typename T>
using BitCounterType = utils::BitCounter<T>
using BitPackerType = utils::BitPacker
using NoMsg = util::fntraits::detail::NoMsg
template<typename T, T init_val, typename Tag>
using Strong = util::strong::detail::Strong<T, init_val, Tag>
Type-alias for strong types.
template<typename ColT, typename MsgT = ::vt::Message>
using CollectionMessage = vrt::collection::CollectionMessage<ColT, MsgT>
template<typename ColT, typename IndexT>
using Collection = vrt::collection::Collection<ColT, IndexT>
template<typename ColT, typename IndexT>
using InsertableCollection = vrt::collection::Collection<ColT, IndexT>
template<typename ColT, typename IndexT = typename ColT::IndexType>
using CollectionIndexProxy = vrt::collection::CollectionProxy<ColT, IndexT>
template<typename ColT, typename IndexT = typename ColT::IndexType>
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 thePerfData() -> metrics::PerfData*
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 const runtime::RuntimeInstType collective_default_inst constexpr
runtime::Runtime* curRT
static const NodeType uninitialized_destination constexpr
static const PhysicalResourceType no_workers constexpr
static const uint64_t u64empty constexpr
static const uint32_t u32empty constexpr
static const int64_t s64empty constexpr
static const int32_t s32empty constexpr
static const int num_check_actions constexpr
static const TagType no_tag constexpr
static const EventType no_event constexpr
static const BarrierType no_barrier constexpr
static const RDMA_HandleType no_rdma_handle constexpr
static const ByteType no_byte constexpr
static const ByteType no_offset constexpr
static auto no_action constexpr
static const RDMA_PtrType no_rdma_ptr constexpr
static const VirtualProxyType no_vrt_proxy constexpr
static const HandlerType uninitialized_handler constexpr
static const RDMA_HandlerType uninitialized_rdma_handler constexpr
static const RefType not_shared_message constexpr
static const RDMA_BlockType no_rdma_block constexpr
static const SeedType no_seed constexpr
static const VirtualElmCountType no_elms constexpr
static const TagType local_rdma_op_tag constexpr
static const GroupType no_group constexpr
static const GroupType default_group constexpr
static const PhaseType fst_lb_phase constexpr
static const PhaseType no_lb_phase constexpr
static const PipeType no_pipe constexpr
static const ObjGroupProxyType no_obj_group constexpr
static const SequentialIDType no_seq_id constexpr
static const SequentialIDType first_seq_id constexpr
static const PriorityType no_priority constexpr
static const PriorityLevelType no_priority_level constexpr
static const ThreadIDType no_thread_id constexpr
static const SharedIDType no_shared_id constexpr
static const BitCountType node_num_bits constexpr
static const BitCountType handler_num_bits constexpr
static const BitCountType ref_num_bits constexpr
static const BitCountType epoch_num_bits constexpr
static const BitCountType tag_num_bits constexpr
static const BitCountType group_num_bits constexpr
static const BitCountType priority_num_bits constexpr
static const BitCountType priority_level_num_bits constexpr
static const EpochType no_epoch constexpr
The sentinel value for a empty epoch.
HandlerType event_finished_han
HandlerType check_event_finished_han
static const HandlerIdentifierType first_handle_identifier constexpr
static const HandlerIdentifierType uninitialized_handle_identifier constexpr
static const HandlerType blank_handler constexpr
static const BitCountType auto_num_bits constexpr
static const BitCountType functor_num_bits constexpr
static const BitCountType trace_num_bits constexpr
static const BitCountType control_num_bits constexpr
static const BitCountType base_msg_derived_num_bits constexpr
static const BitCountType registry_type_bits constexpr
static const BitCountType 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 const PriorityType sys_max_priority constexpr
static const PriorityType sys_min_priority constexpr
static const PriorityType max_priority constexpr
static const PriorityType min_priority constexpr
static const PriorityType default_priority constexpr

Enum documentation

Typedef documentation

using vt::ActiveClosureFnType = std::function<void(vt::BaseMessage*)>
#include <src/vt/activefn/activefn.h>

using vt::ActiveVoidFnType = void()
#include <src/vt/activefn/activefn.h>

#include <src/vt/activefn/activefn.h>
template<typename MessageT>
using vt::ActiveTypedFnType = void(MessageT*)

#include <src/vt/activefn/activefn.h>
template<typename MessageT>
using vt::ActiveTypedRDMAGetFnType = RDMA_GetType(MessageT*, ByteType, ByteType, TagType, bool)

#include <src/vt/activefn/activefn.h>
template<typename MessageT>
using vt::ActiveTypedRDMAPutFnType = void(MessageT*, RDMA_PtrType, ByteType, ByteType, TagType, bool)

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_ContinuationType = std::function<void(RDMA_GetType)>
#include <src/vt/configs/types/types_rdma.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::SharedIDType = int
#include <src/vt/configs/types/types_type.h>

Used to hold a shared ID.

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::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::PutPtrConstType = std::byte const *
#include <src/vt/messaging/envelope/payload_envelope.h>

using vt::BaseMessage = messaging::BaseMsg
#include <src/vt/messaging/message/message.h>

Alias to the base of all messages.

#include <src/vt/messaging/message/message.h>
template<typename EnvelopeT>
using vt::ActiveMessage = messaging::ActiveMsg<EnvelopeT>

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)

#include <src/vt/messaging/message/message_serialize.h>
template<typename MsgT, typename SelfT>
using vt::NonSerialized = vt::messaging::NonSerializedMsg<MsgT, SelfT>

#include <src/vt/messaging/message/message_serialize.h>
template<typename MsgT, typename SelfT>
using vt::SerializeSupported = vt::messaging::SerializeSupportedMsg<MsgT, SelfT>

#include <src/vt/messaging/message/message_serialize.h>
template<typename MsgT, typename SelfT>
using vt::SerializeRequired = vt::messaging::SerializeRequiredMsg<MsgT, SelfT>

#include <src/vt/messaging/message/message_serialize.h>
template<typename MsgT, typename SelfT, typename ... DepTypesT>
using vt::SerializeIfNeeded = vt::messaging::SerializeIfNeededMsg<MsgT, SelfT, DepTypesT...>

#include <src/vt/messaging/message/smart_ptr.h>
template<typename T>
using vt::MsgVirtualPtr = messaging::MsgSharedPtr<T>

\obsolete Use MsgPtr<T>, for which this is an alias.

using vt::MsgVirtualPtrAny = messaging::MsgSharedPtr<ShortMessage>
#include <src/vt/messaging/message/smart_ptr.h>

\obsolete Use MsgPtr<ShortMessage>, or as appropriate.

#include <src/vt/messaging/message/smart_ptr.h>
template<typename T>
using vt::MsgSharedPtr = messaging::MsgSharedPtr<T>

\obsolete Use MsgPtr<T>, for which this is an alias.

#include <src/vt/messaging/message/smart_ptr.h>
template<typename T>
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.

#include <src/vt/rdmahandle/handle.h>
template<typename T, typename I = vt::NodeType>
using vt::HandleRDMA = rdma::Handle<T, rdma::HandleEnum::StaticSize, I>

#include <src/vt/termination/interval/integral_set.h>
template<typename DomainT>
using vt::IntegralSet = term::interval::IntegralSetBase<DomainT, DomainT{}, std::allocator, term::interval::Interval, std::set, IntervalCompare>

#include <src/vt/termination/interval/interval.h>
template<typename DomainT>
using vt::IntervalCompare = term::interval::IntervalCompare<DomainT>

#include <src/vt/termination/interval/interval.h>
template<typename DomainT>
using vt::Interval = term::interval::Interval<DomainT>

#include <src/vt/topos/index/index.h>
template<typename IndexType, index::NumDimensionsType ndim>
using vt::DenseIndex = index::DenseIndexArray<IndexType, ndim>

#include <src/vt/topos/index/index.h>
template<int8_t N>
using vt::IndexND = index::IdxType<index::IdxBase, N>

#include <src/vt/topos/index/index.h>
template<typename T, int8_t N>
using vt::IdxType = index::IdxType<T, N>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType1D = index::Index1D<T>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType2D = index::Index2D<T>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType3D = index::Index3D<T>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType4D = index::Index4D<T>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType5D = index::Index5D<T>

#include <src/vt/topos/index/index.h>
template<typename T>
using vt::IdxType6D = index::Index6D<T>

#include <src/vt/topos/location/message/msg.h>
template<typename EntityID, typename ActiveMessageT>
using vt::LocationRoutedMsg = location::EntityMsg<EntityID, ActiveMessageT>

#include <src/vt/utils/bits/bits_common.h>
template<typename T>
using vt::BitCounterType = utils::BitCounter<T>

#include <src/vt/utils/strong/strong_type.h>
template<typename T, T init_val, typename Tag>
using vt::Strong = util::strong::detail::Strong<T, init_val, Tag>

Type-alias for strong types.

#include <src/vt/vrt/collection/messages/user.h>
template<typename ColT, typename MsgT = ::vt::Message>
using vt::CollectionMessage = vrt::collection::CollectionMessage<ColT, MsgT>

#include <src/vt/vrt/collection/types/type_aliases.h>
template<typename ColT, typename IndexT>
using vt::Collection = vrt::collection::Collection<ColT, IndexT>

#include <src/vt/vrt/collection/types/type_aliases.h>
template<typename ColT, typename IndexT>
using vt::InsertableCollection = vrt::collection::Collection<ColT, IndexT>

#include <src/vt/vrt/proxy/collection_proxy.h>
template<typename ColT, typename IndexT = typename ColT::IndexType>
using vt::CollectionIndexProxy = vrt::collection::CollectionProxy<ColT, IndexT>

#include <src/vt/vrt/proxy/collection_proxy.h>
template<typename ColT, typename IndexT = typename ColT::IndexType>
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.h>

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.h>

int vt::rerror(char const* str)
#include <src/vt/collective/basic.h>

std::unique_ptr<arguments::ArgvContainer> vt::preconfigure(int& argc, char**& argv)
#include <src/vt/collective/startup.h>

RuntimePtrType vt::initializePreconfigured(MPI_Comm* comm, arguments::AppConfig const* appConfig, arguments::ArgvContainer const* preconfigure_args)
#include <src/vt/collective/startup.h>

RuntimePtrType vt::initialize(int& argc, char**& argv, MPI_Comm* comm, arguments::AppConfig const* appConfig)
#include <src/vt/collective/startup.h>

RuntimePtrType vt::initialize(int& argc, char**& argv, arguments::AppConfig const* appConfig)
#include <src/vt/collective/startup.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)

#include <src/vt/messaging/envelope/envelope_extended_util.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

#include <src/vt/messaging/envelope/envelope_extended_util.h>
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

#include <src/vt/messaging/envelope/envelope_extended_util.h>
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

#include <src/vt/messaging/envelope/envelope_extended_util.h>
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)
#include <src/vt/messaging/envelope/envelope_extended_util.h>

Initialize an epoch envelope with default values.

Parameters
env in/out the envelope

void vt::envelopeInitEmpty(TagEnvelope& env)
#include <src/vt/messaging/envelope/envelope_extended_util.h>

Initialize an tag envelope with default values.

Parameters
env in/out the envelope

void vt::envelopeInitEmpty(EpochTagEnvelope& env)
#include <src/vt/messaging/envelope/envelope_extended_util.h>

Initialize an epoch and tag envelope with default values.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_get.h>
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

#include <src/vt/messaging/envelope/envelope_get.h>
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

#include <src/vt/messaging/envelope/envelope_get.h>
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

#include <src/vt/messaging/envelope/envelope_get.h>
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

#include <src/vt/messaging/envelope/envelope_get.h>
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

#include <src/vt/messaging/envelope/envelope_ref.h>
template<typename Env>
void vt::envelopeRef(Env& env)

Increase the reference count on an envelope.

Parameters
env in the envelope

#include <src/vt/messaging/envelope/envelope_ref.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
template<typename Env>
void vt::setNormalType(Env& env)

Clear all type bits make "normal".

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_set.h>
template<typename Env>
void vt::setPipeType(Env& env)

Set pipe bit EnvPipe.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_set.h>
template<typename Env>
void vt::setPutType(Env& env)

Set put bit EnvPut.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_set.h>
template<typename Env>
void vt::setTermType(Env& env)

Set term bit EnvTerm.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_set.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
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.

#include <src/vt/messaging/envelope/envelope_set.h>
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.

#include <src/vt/messaging/envelope/envelope_set.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
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.

#include <src/vt/messaging/envelope/envelope_set.h>
template<typename Env>
void vt::envelopeSetGroup(Env& env, GroupType const& group = default_group)

Set pipe bit EnvPipe.

Parameters
env in/out the envelope
group

#include <src/vt/messaging/envelope/envelope_set.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
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

#include <src/vt/messaging/envelope/envelope_set.h>
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.

#include <src/vt/messaging/envelope/envelope_set.h>
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.

#include <src/vt/messaging/envelope/envelope_setup.h>
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

#include <src/vt/messaging/envelope/envelope_setup.h>
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)
#include <src/vt/messaging/envelope/envelope_setup.h>

Initialize an envelope without defaults.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/envelope_setup.h>
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.

#include <src/vt/messaging/envelope/envelope_setup.h>
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

#include <src/vt/messaging/envelope/envelope_setup.h>
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)
#include <src/vt/messaging/envelope/payload_envelope.h>

Initialize a PutEnvelope with extra put-related fields.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/payload_envelope.h>
template<typename Env>
PutPtrType vt::envelopeGetPutPtr(Env const& env)

Get the put pointer.

Parameters
env in the envelope
Returns the put pointer

#include <src/vt/messaging/envelope/payload_envelope.h>
template<typename Env>
PutEnvSizeType vt::envelopeGetPutSize(Env const& env)

Get the put payload byte length.

Parameters
env in the envelope
Returns the put length

#include <src/vt/messaging/envelope/payload_envelope.h>
template<typename Env>
TagType vt::envelopeGetPutTag(Env const& env)

Get the put tag.

Parameters
env in the envelope
Returns the put tag

#include <src/vt/messaging/envelope/payload_envelope.h>
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

#include <src/vt/messaging/envelope/payload_envelope.h>
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

#include <src/vt/messaging/envelope/payload_envelope.h>
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

#include <src/vt/messaging/envelope/payload_envelope.h>
template<typename Env>
void vt::setPackedPutType(Env& env)

Set the envelope type bit for EnvPackedPut.

Parameters
env in/out the envelope

#include <src/vt/messaging/envelope/payload_envelope.h>
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)

#include <src/vt/messaging/message/shared_message.h>
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.

#include <src/vt/messaging/message/shared_message.h>
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.

#include <src/vt/messaging/message/shared_message.h>
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.

#include <src/vt/messaging/message/shared_message.h>
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.

#include <src/vt/messaging/message/smart_ptr.h>
template<typename T>
MsgPtr<T> vt::promoteMsgOwner(T*const msg)

Obsolete form - do not use. There is no direct replacement; has_owner_ is removed.

#include <src/vt/messaging/message/smart_ptr.h>
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*).

#include <src/vt/messaging/message/smart_ptr.h>
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.

#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)

#include <src/vt/vrt/collection/param/construct_params.h>
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

#include <src/vt/vrt/collection/param/construct_params.h>
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 const uint64_t vt::u64empty constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const uint32_t vt::u32empty constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const int64_t vt::s64empty constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const int32_t vt::s32empty constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const int vt::num_check_actions constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const TagType vt::no_tag constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const EventType vt::no_event constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const ByteType vt::no_byte constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const ByteType vt::no_offset constexpr
#include <src/vt/configs/types/types_sentinels.h>

static auto vt::no_action constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const SeedType vt::no_seed constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const GroupType vt::no_group constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const PhaseType vt::no_lb_phase constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const PipeType vt::no_pipe constexpr
#include <src/vt/configs/types/types_sentinels.h>

static const BitCountType vt::node_num_bits constexpr
#include <src/vt/configs/types/types_size.h>

static const BitCountType vt::ref_num_bits constexpr
#include <src/vt/configs/types/types_size.h>

static const BitCountType vt::tag_num_bits constexpr
#include <src/vt/configs/types/types_size.h>

static const EpochType vt::no_epoch constexpr
#include <src/vt/epoch/epoch_type.h>

The sentinel value for a empty epoch.

static const HandlerType vt::blank_handler constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::auto_num_bits constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::functor_num_bits constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::trace_num_bits constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::control_num_bits constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::registry_type_bits constexpr
#include <src/vt/handler/handler.h>

static const BitCountType vt::handler_id_num_bits constexpr
#include <src/vt/handler/handler.h>

static const PriorityType vt::sys_max_priority constexpr
#include <src/vt/scheduler/priority.h>

static const PriorityType vt::sys_min_priority constexpr
#include <src/vt/scheduler/priority.h>

static const PriorityType vt::max_priority constexpr
#include <src/vt/scheduler/priority.h>

static const PriorityType vt::min_priority constexpr
#include <src/vt/scheduler/priority.h>

static const PriorityType vt::default_priority constexpr
#include <src/vt/scheduler/priority.h>