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

The base class for all messages. Common alias is vt::Message which uses the default envelope.

This is templated over the envelope to allow longer or shorter messages to be used depending on the target and needed envelope bits.

Base classes

struct BaseMsg
The very lowest base class for a message. Used by the runtime to cast on delivery to handlers without type knowledge.

Derived classes

template<typename MessageT>
struct PutMessageComponent
template<typename EnvelopeT>
struct vt::rdma::RDMAOpFinishedMessage
template<typename EnvelopeT>
struct vt::rdma::RequestDataMessage
template<typename EnvelopeT>
struct vt::rdma::SendDataMessage
template<typename EnvelopeT>
struct vt::rdma::RDMAOpFinishedMessage
template<typename EnvelopeT>
struct vt::rdma::RequestDataMessage
template<typename EnvelopeT>
struct vt::rdma::SendDataMessage

Public types

using EnvelopeType = EnvelopeT
using MessageParentType = BaseMsg

Public static functions

static auto operator new(std::size_t sz) -> void*
Overload of the new operator to use the memory pool to construct a new message.
static auto operator new(std::size_t sz, std::size_t oversize) -> void*
Overload of the new operator to use the memory pool to construct a new message with some extra memory after the message for a put payload.
static void operator delete(void* ptr)
Overload of delete to use the memory pool to de-allocate a message.
static auto operator new(std::size_t, void* mem) -> void*
Overload of the new operator for in-place allocations.

Constructors, destructors, conversion operators

ActiveMsg()
Construct an empty message; initializes the envelope state.
vt_msg_serialize_mode_(support)

Public functions

template<typename SerializerT>
void serialize(SerializerT& s)
Explicitly serialize this message.

Public variables

EnvelopeType env

Function documentation

template<typename EnvelopeT>
static void* vt::messaging::ActiveMsg<EnvelopeT>::operator new(std::size_t sz)

Overload of the new operator to use the memory pool to construct a new message.

Parameters
sz in the size to allocate
Returns a pointer to the allocated memory

template<typename EnvelopeT>
static void* vt::messaging::ActiveMsg<EnvelopeT>::operator new(std::size_t sz, std::size_t oversize)

Overload of the new operator to use the memory pool to construct a new message with some extra memory after the message for a put payload.

Parameters
sz in the message size to allocate
oversize in the extra size to allocate
Returns a pointer to the allocated memory

template<typename EnvelopeT>
static void vt::messaging::ActiveMsg<EnvelopeT>::operator delete(void* ptr)

Overload of delete to use the memory pool to de-allocate a message.

Parameters
ptr in the pointer to deallocate

template<typename EnvelopeT>
static void* vt::messaging::ActiveMsg<EnvelopeT>::operator new(std::size_t, void* mem)

Overload of the new operator for in-place allocations.

Parameters
mem in the memory to in-place allocation
Returns the pointer

template<typename EnvelopeT> template<typename SerializerT>
void vt::messaging::ActiveMsg<EnvelopeT>::serialize(SerializerT& s)

Explicitly serialize this message.

Parameters
s in the serializer

Should be called froms derived type that support/require serialization.