vt::rdma namespace

Namespaces

namespace impl

Classes

struct Action

struct BaseHandle

The untyped, lowest base class for all handles.

template<typename T, HandleEnum E, typename IndexT>

struct BaseTypedHandle

The typed base class for all types of handles.

template<typename IndexT>

struct Cache

struct Channel

struct ChannelLookup

struct ChannelMessage

struct CollectionInfo

struct CreateChannel

struct Endpoint

struct GetInfoChannel

struct Group

template<typename T, HandleEnum E = rdma::HandleEnum::StaticSize, typename IndexT = vt::NodeType, typename = void>

struct Handle

Handle specialization for index-level RDMA access (overdecomposed)

struct HandleKey

struct HandleManager

template<typename T>

struct HandleSet

Holds a static (non-migratable) set of handles that can be indexed built by an objgroup for sub-chunking.

template<typename T, HandleEnum E>

struct Holder

struct IndexInfo

struct Info

struct LockMPI

struct Manager

RDMA Handle Manager for creation of node- or index-level handles.

struct Map

struct NonTarget

struct Pending

struct RDMACollectionManager

struct RDMAManager

Core component of VT used to send pure data to registered RDMA handlers or memory locations.

template<typename EnvelopeT>

struct RDMAOpFinishedMessage

struct Region

template<typename EnvelopeT>

struct RequestDataMessage

struct RequestHolder

template<typename EnvelopeT>

struct SendDataMessage

struct State

template<typename StateT>

struct StateMessage

template<typename T, HandleEnum E, typename IndexT>

struct SubHandle

struct Target

template<typename T>

struct TypeMPI

template<>

struct TypeMPI<char>

template<>

struct TypeMPI<double>

template<>

struct TypeMPI<float>

template<>

struct TypeMPI<int16_t>

template<>

struct TypeMPI<int32_t>

template<>

struct TypeMPI<int64_t>

template<>

struct TypeMPI<int8_t>

template<>

struct TypeMPI<long double>

template<>

struct TypeMPI<uint16_t>

template<>

struct TypeMPI<uint32_t>

template<>

struct TypeMPI<uint64_t>

template<>

struct TypeMPI<uint8_t>

template<>

struct TypeMPI<wchar_t>

template<typename T, HandleEnum E, typename IndexT>

struct Handle<T, E, IndexT, typename std::enable_if_t<not std::is_same<IndexT, vt::NodeType>::value>>

template<typename T, HandleEnum E, typename IndexT>

struct Handle<T, E, IndexT, typename std::enable_if_t<std::is_same<IndexT, vt::NodeType>::value>>

Enums

enum Type { Get = 0, Put = 1, GetOrPut = 2, Uninitialized = 3 }

enum Bits { Sized = 0, Collective = Bits::Sized + rdma_sized_num_bits, HandlerType = Bits::Collective + rdma_collective_num_bits, OpType = Bits::HandlerType + rdma_hander_type_num_bits, Identifier = Bits::OpType + rdma_type_num_bits, Node = Bits::Identifier + rdma_identifier_num_bits }

enum class HandleEnum { StaticSize = 1, ConcurrentList = 2 }

enum class Lock: int8_t { None = 0, Exclusive = 1, Shared = 2 }

Typedefs

using RegionElmSizeType = int32_t

using RDMA_IdentifierType = int32_t

using RDMA_OpType = int64_t

template<typename MsgType>

using ActiveTypedGetFunctionType = RDMA_GetType(*)(MsgType*, ByteType, ByteType, TagType, bool)

template<typename MsgType>

using ActiveTypedPutFunctionType = void(*)(MsgType*, RDMA_PtrType, ByteType, ByteType, TagType, bool)

using ActiveGetFunctionType = RDMA_GetType(*)(BaseMessage*, ByteType, ByteType, TagType, bool)

using ActivePutFunctionType = void(*)(BaseMessage*, RDMA_PtrType, ByteType, ByteType, TagType, bool)

using RDMA_PtrContinuationType = std::function<void(RDMA_PtrType)>

using RDMA_RecvType = std::function<void(std::byte*ptr, size_t num_bytes)>

using RDMA_NumElemsType = int64_t

using RDMA_BlockElmRangeType = std::tuple<RDMA_BlockType, RDMA_ElmType, RDMA_ElmType>

using RDMA_BlockMapType = std::function<NodeType(RDMA_BlockType, RDMA_BlockType)>

using RDMA_ElmMapType = std::function<RDMA_BlockElmRangeType(RDMA_ElmType, RDMA_ElmType, RDMA_BlockType)>

using RDMA_HandleManagerType = HandleManager

using GetMessage = RequestDataMessage<EpochTagEnvelope>

using GetBackMessage = SendDataMessage<EpochTagEnvelope>

using PutMessage = SendDataMessage<EpochTagEnvelope>

using PutBackMessage = RDMAOpFinishedMessage<EpochTagEnvelope>

using DestroyChannel = ChannelMessage

using UnderlyingNodeType = NodeType

using ElemType = int64_t

Functions

auto operator==(ChannelLookup const& c1, ChannelLookup const& c2) -> bool

Variables

const ByteType rdma_elm_size constexpr

const ByteType rdma_empty_byte constexpr

static Map default_map

static const RegionElmSizeType no_elm_size constexpr

static const RDMA_IdentifierType first_rdma_identifier constexpr

static const RDMA_IdentifierType uninitialized_rdma_identifier constexpr

static const TagType first_rdma_channel_tag constexpr

static const BitCountType rdma_type_num_bits constexpr

static const BitCountType rdma_sized_num_bits constexpr

static const BitCountType rdma_collective_num_bits constexpr

static const BitCountType rdma_hander_type_num_bits constexpr

static const BitCountType rdma_identifier_num_bits constexpr

static const RDMA_OpType no_rdma_op constexpr

static Type uninitialized_rdma_type constexpr

static ByteType rdma_default_byte_size constexpr

static const RDMA_HandlerType first_rdma_handler constexpr

Enum documentation

Typedef documentation

Function documentation

Variable documentation