vt::messaging namespace

Namespaces

namespace detail
namespace statics

Classes

struct ActiveEnvelope
The foundational basic envelope that every VT message has as the first member.
struct ActiveMessenger
Core component of VT used to send messages.
template<typename EnvelopeT>
struct ActiveMsg
The base class for all messages. Common alias is vt::Message which uses the default envelope.
struct AsyncOp
A general asynchronous operation with a pure virtual polling function and an associated trigger to execute when it completes.
struct AsyncOpMPI
An asynchronous MPI request that VT can poll on until completion.
struct AsyncOpWrapper
Wrapper for a general asynchronous operation that holds a pointer to base class.
struct BaseMsg
The very lowest base class for a message. Used by the runtime to cast on delivery to handlers without type knowledge.
struct BufferedActiveMsg
Holds a buffered active message, used internally.
template<typename Index>
struct CollectionChainSet
A set of chains to maintain a sequence for a set of collection elements that may be local or remote.
template<class...>
struct cxx14_conjunction
template<class B1>
struct cxx14_conjunction<B1>
template<class B1, class... Bn>
struct cxx14_conjunction<B1, Bn...>
template<typename... Ts>
struct cxx14_make_void
template<typename MsgT>
struct DefinesSerializationMode
struct DependentSendChain
A sequenced chain of sends ordered by termination detection.
struct EpochActiveEnvelope
Extended envelope that holds an epoch, contains all of ActiveEnvelope.
struct EpochTagActiveEnvelope
Extended envelope that holds an epoch and tag, contains all of ActiveEnvelope.
template<class T>
struct has_any_serialize_member_t
template<typename U, typename = void>
struct has_own_serialize_member_t
template<typename U>
struct has_own_serialize_member_t<U, std::enable_if_t<std::is_same<void(U::*)(::checkpoint::Sizer&), decltype(&U::template serialize<SerializeSizerType>)>::value>>
struct InProgressBase
Base class for an in-progress MPI operation.
struct InProgressDataIRecv
An in-progress pure data MPI_Irecv watched by the runtime.
struct InProgressIRecv
An in-progress MPI_Irecv watched by the runtime.
template<typename T>
struct is_byte_copyable_t
struct MergedClosure
A copyable closure that holds a PendingSend that will be released when all shared instances of this closure are destroyed.
template<typename U, typename = void>
struct msg_defines_serialize_mode
template<typename U>
struct msg_defines_serialize_mode<U, std::enable_if_t<std::is_base_of<DefinesSerializationMode<U>, U>::value>>
template<typename U>
struct msg_defines_serialize_mode<U, std::enable_if_t<std::is_same<void(U::*)(), decltype(&U::vt_serialize_defined_on_type)>::value>>
template<typename MessageT, typename = void>
struct msg_serialization_mode
struct MsgPtrImplBase
Message-type agnostic virtual base class.
template<typename MsgT>
struct MsgPtrImplTyped
template<typename MsgT>
struct MsgPtrThief
Helper to unify 'stealing' message ownership.
template<typename T>
struct MsgSharedPtr
struct MultiMsg
template<typename MsgT, typename SelfT>
struct NonSerializedMsg
template<typename Tuple, typename enabled = void>
struct ParamMsg
struct PendingClosure
A move-only closure that holds a PendingSend that is typically waiting for termination of another epoch before being released.
struct PendingRecv
An pending receive event.
struct PendingSend
A pending send (or other similar operation) that is delayed until this holder goes out of scope.
template<typename MessageT>
struct PutMessageComponent
template<typename T>
struct RequestHolder
Holds a set of pending MPI Irecvs to poll for completion.
struct SendInfo
Returned from a data send to be used to receive the data.
template<typename MsgT, typename SelfT, typename ... DepTypesT>
struct SerializeIfNeededMsg
template<typename MsgT, typename SelfT>
struct SerializeRequiredMsg
template<typename MsgT, typename SelfT>
struct SerializeSupportedMsg
struct TagActiveEnvelope
Extended envelope that holds a tag, contains all of ActiveEnvelope.
template<typename Tuple>
struct ParamMsg<Tuple, std::enable_if_t<is_byte_copyable_t<Tuple>::value>>
template<typename Tuple>
struct ParamMsg<Tuple, std::enable_if_t<not is_byte_copyable_t<Tuple>::value>>
template<typename MessageT>
struct msg_serialization_mode<MessageT, cxx14_void_t<decltype(MessageT::vt_serialize_mode)>>

Enums

enum MPITag { ActiveMsgTag = 1, DataMsgTag = 2 }
enum ChainSetLayout { Local, Home }
Used to specify the layout for automatically managing dependency chains for a given collection.
enum eEnvelopeType { EnvPipe = 0, EnvPut = 1, EnvTerm = 2, EnvBroadcast = 3, EnvEpochType = 4, EnvTagType = 5, EnvPackedPut = 6 }
Enum for envelope type bits, used to cast to sub-types and interpret bits.
enum SerializationMode { support = 1, require = 2, prohibit = 3 }

Typedefs

using MPI_TagType = int
using cxx14_void_t = typename cxx14_make_void<Ts...>::type
using SerializeSizerType = ::checkpoint::Sizer

Functions

template<typename Env>
auto envelopeIsTerm(Env const& env) -> bool
Test if envelope type is term EnvTerm.
template<typename Env>
auto envelopeIsPipe(Env const& env) -> bool
Test if envelope type is pipe EnvPipe.
template<typename Env>
auto envelopeIsPut(Env const& env) -> bool
Test if envelope type is put EnvPut.
template<typename Env>
auto envelopeIsBcast(Env const& env) -> bool
Test if envelope type is broadcast EnvBroadcast.
template<typename Env>
auto envelopeIsEpochType(Env const& env) -> bool
Test if envelope type is epoch EnvEpoch.
template<typename Env>
auto envelopeIsTagType(Env const& env) -> bool
Test if envelope type is tag EnvTag.
template<typename Env>
auto envelopeHasBeenSerialized(Env& env) -> bool
Test if the message's base serializer has been called.
template<typename Env>
auto envelopeIsLocked(Env& env) -> bool
Test if the message's envelope has been locked.
template<typename Env>
auto envelopeCommLBDataRecordedAboveBareHandler(Env& env) -> bool
Test if an envelope indicates that bare handlers shouldn't record LB comm LB data.
template<typename MsgT>
void msgSetPriorityLevel(MsgT ptr, PriorityLevelType level)
template<typename MsgT>
void msgSetPriorityAllLevels(MsgT ptr, PriorityType priority)
template<typename MsgT, typename MsgU>
auto msgIncPriorityLevel(MsgT old_msg, MsgU new_msg) -> bool
template<typename MsgU>
void msgSetPriority(MsgU new_msg, PriorityType priority, bool increment_level = false)
template<typename MsgU>
void msgSetPriorityImpl(MsgU new_msg, PriorityType new_priority, PriorityType old_priority, PriorityLevelType level)
template<typename MsgT, typename MsgU>
void msgSetPriorityFrom(MsgT old_msg, MsgU new_msg, PriorityType priority, bool increment_level = false)
template<typename MsgT>
void msgSystemSetPriority(MsgT ptr, PriorityType priority)

Variables

static TagType const PutPackedTag constexpr
static TagType const starting_direct_buffer_tag constexpr
static MsgSizeType const max_pack_direct_size constexpr
NodeType broadcast_dest constexpr
static BitCountType const envelope_num_bits constexpr
Number of bits allocated for eEnvelopeType.
template<typename T>
static auto const has_own_serialize constexpr

Enum documentation

enum vt::messaging::MPITag
#include <src/vt/messaging/active.h>

enum vt::messaging::ChainSetLayout
#include <src/vt/messaging/collection_chain_set.h>

Used to specify the layout for automatically managing dependency chains for a given collection.

Enumerators
Local

Track dependencies where element is located
Home

Track dependencies on the home node

enum vt::messaging::eEnvelopeType
#include <src/vt/messaging/envelope/envelope_type.h>

Enum for envelope type bits, used to cast to sub-types and interpret bits.

Enumerators
EnvPipe

Whether to interpret group field as pipe
EnvPut

Whether the envelope has a PUT payload
EnvTerm

Whether the message is a term control msg
EnvBroadcast

Whether the message is being broadcast
EnvEpochType

Whether the envelope can hold an epoch
EnvTagType

Whether the envelope can hold a tag
EnvPackedPut

Whether the message is packed with data

Typedef documentation

using vt::messaging::MPI_TagType = int
#include <src/vt/messaging/active.h>

using vt::messaging::cxx14_void_t = typename cxx14_make_void<Ts...>::type
#include <src/vt/messaging/message/message_serialize.h>

Function documentation

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsTerm(Env const& env)

Test if envelope type is term EnvTerm.

Parameters
env in the envelope
Returns whether the bit is set

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsPipe(Env const& env)

Test if envelope type is pipe EnvPipe.

Parameters
env in the envelope
Returns whether the bit is set

This designation if enabled changes how the group bits are interpreted—either as the GroupType or PipeType. Note that this works because its impossible for a message to be sent both as a group and pipe simultaneously.

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsPut(Env const& env)

Test if envelope type is put EnvPut.

Parameters
env in the envelope
Returns whether the bit is set

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsBcast(Env const& env)

Test if envelope type is broadcast EnvBroadcast.

Parameters
env in the envelope
Returns whether the bit is set

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsEpochType(Env const& env)

Test if envelope type is epoch EnvEpoch.

Parameters
env in the envelope
Returns whether the bit is set

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsTagType(Env const& env)

Test if envelope type is tag EnvTag.

Parameters
env in the envelope
Returns whether the bit is set

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeHasBeenSerialized(Env& env)

Test if the message's base serializer has been called.

Parameters
env in the envelope

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeIsLocked(Env& env)

Test if the message's envelope has been locked.

Parameters
env in the envelope

#include <src/vt/messaging/envelope/envelope_test.h>
template<typename Env>
bool vt::messaging::envelopeCommLBDataRecordedAboveBareHandler(Env& env)

Test if an envelope indicates that bare handlers shouldn't record LB comm LB data.

Parameters
env in the envelope

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgT>
void vt::messaging::msgSetPriorityLevel(MsgT ptr, PriorityLevelType level)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgT>
void vt::messaging::msgSetPriorityAllLevels(MsgT ptr, PriorityType priority)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgT, typename MsgU>
bool vt::messaging::msgIncPriorityLevel(MsgT old_msg, MsgU new_msg)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgU>
void vt::messaging::msgSetPriority(MsgU new_msg, PriorityType priority, bool increment_level = false)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgU>
void vt::messaging::msgSetPriorityImpl(MsgU new_msg, PriorityType new_priority, PriorityType old_priority, PriorityLevelType level)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgT, typename MsgU>
void vt::messaging::msgSetPriorityFrom(MsgT old_msg, MsgU new_msg, PriorityType priority, bool increment_level = false)

#include <src/vt/messaging/message/message_priority.h>
template<typename MsgT>
void vt::messaging::msgSystemSetPriority(MsgT ptr, PriorityType priority)

Variable documentation

static TagType const vt::messaging::PutPackedTag constexpr
#include <src/vt/messaging/active.h>

static TagType const vt::messaging::starting_direct_buffer_tag constexpr
#include <src/vt/messaging/active.h>

static MsgSizeType const vt::messaging::max_pack_direct_size constexpr
#include <src/vt/messaging/active.h>

NodeType vt::messaging::broadcast_dest constexpr
#include <src/vt/messaging/active.impl.h>

static BitCountType const vt::messaging::envelope_num_bits constexpr
#include <src/vt/messaging/envelope/envelope_type.h>

Number of bits allocated for eEnvelopeType.

#include <src/vt/messaging/message/message_serialize.h>
template<typename T>
static auto const vt::messaging::has_own_serialize constexpr