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 class MPITag: MPI_TagType { 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 class SerializationMode: int { support = 1, require = 2, prohibit = 3 }

Typedefs

using MPI_TagType = int
template<typename... Ts> 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)
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)
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)
template<typename MsgT> void msgSystemSetPriority(] MsgT ptr, ] PriorityType priority)

Variables

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

Enum documentation

enum class vt::messaging::MPITag: MPI_TagType
#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

enum class vt::messaging::SerializationMode: int
#include <src/vt/messaging/message/message_serialize.h>

Typedef documentation

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

#include <src/vt/messaging/message/message_serialize.h>

template<typename... Ts>
using vt::messaging::cxx14_void_t = typename cxx14_make_void<Ts...>::type

using vt::messaging::SerializeSizerType = ::checkpoint::Sizer
#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)

#include <src/vt/messaging/message/message_priority.impl.h>

template<typename MsgT>
void vt::messaging::msgSetPriorityLevel(] MsgT ptr, ] PriorityLevelType level)

#include <src/vt/messaging/message/message_priority.impl.h>

template<typename MsgT>
void vt::messaging::msgSetPriorityAllLevels(] MsgT ptr, ] PriorityType priority)

#include <src/vt/messaging/message/message_priority.impl.h>

template<typename MsgT, typename MsgU>
bool vt::messaging::msgIncPriorityLevel(] MsgT old_msg, ] MsgU new_msg)

#include <src/vt/messaging/message/message_priority.impl.h>

template<typename MsgU>
void vt::messaging::msgSetPriority(] MsgU new_msg, ] PriorityType priority, ] bool increment_level)

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

template<typename MsgT, typename MsgU>
void vt::messaging::msgSetPriorityFrom(] MsgT old_msg, ] MsgU new_msg, ] PriorityType priority, ] bool increment_level)

#include <src/vt/messaging/message/message_priority.impl.h>

template<typename MsgT>
void vt::messaging::msgSystemSetPriority(] MsgT ptr, ] PriorityType priority)

Variable documentation

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

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

static const MsgSizeType 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 const BitCountType vt::messaging::envelope_num_bits constexpr
#include <src/vt/messaging/envelope/envelope_type.h>

Number of bits allocated for eEnvelopeType.

vt::messaging namespace

Namespaces

Classes

Enums

Typedefs

Functions

Variables

Enum documentation

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

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

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

enum class vt::messaging::SerializationMode: int #include <src/vt/messaging/message/message_serialize.h>

Typedef documentation

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

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

using vt::messaging::SerializeSizerType = ::checkpoint::Sizer #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)

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <src/vt/messaging/message/message_priority.impl.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.impl.h> template<typename MsgT, typename MsgU> void vt::messaging::msgSetPriorityFrom(] MsgT old_msg, ] MsgU new_msg, ] PriorityType priority, ] bool increment_level)

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