Fast-CDR/
├── include/fastcdr/           # 公开头文件
│   ├── Cdr.h                  # 标准 CDR（3557 行，核心 API）
│   ├── FastCdr.h              # Fast CDR（2104 行）
│   ├── FastBuffer.h           # 字节缓冲区 + iterator
│   ├── config.h.in            # 构建时生成的配置宏
│   ├── fastcdr_dll.h          # DLL 导出 / 自动链接
│   ├── eProsima_auto_link.h   # MSVC 自动链接
│   └── exceptions/            # 异常类
│       ├── Exception.h
│       ├── NotEnoughMemoryException.h
│       └── BadParamException.h
├── src/cpp/                   # 实现（6 个 .cpp，约 3600 行）
│   ├── Cdr.cpp                # 2746 行
│   ├── FastCdr.cpp            # 813 行
│   ├── FastBuffer.cpp         # 104 行
│   └── exceptions/
├── test/                      # gtest 单元测试
│   ├── SimpleTest.cpp         # 6931 行，覆盖全部基本类型
│   └── ResizeTest.cpp
├── cmake/                     # 构建辅助、打包
├── configure.ac               # 版本号 autotools 源
├── CMakeLists.txt             # 主构建入口
└── colcon.pkg                 # colcon 元数据

bool FastBuffer::resize(
        size_t minSizeInc)
{
    size_t incBufferSize = BUFFER_START_LENGTH;

    if (m_internalBuffer)
    {
        if (minSizeInc > BUFFER_START_LENGTH)
        {
            incBufferSize = minSizeInc;
        }

        if (m_buffer == NULL)
        {
            m_bufferSize = incBufferSize;

            m_buffer = reinterpret_cast<char*>(malloc(m_bufferSize));
            // ...
        }
        else
        {
            m_bufferSize += incBufferSize;

            m_buffer = reinterpret_cast<char*>(realloc(m_buffer, m_bufferSize));
            // ...
        }
    }

    return false;
}

template<typename _T>
inline
void operator <<(
        const _T& data)
{
    memcpy(m_currentPosition, &data, sizeof(_T));
}

template<typename _T>
inline
void operator >>(
        _T& data)
{
    memcpy(&data, m_currentPosition, sizeof(_T));
}

typedef enum
{
    //! @brief Common CORBA CDR serialization.
    CORBA_CDR,
    //! @brief DDS CDR serialization.
    DDS_CDR
} CdrType;

typedef enum : uint8_t
{
    DDS_CDR_WITHOUT_PL = 0x0,
    DDS_CDR_WITH_PL = 0x2
} DDSCdrPlFlag;

typedef enum : uint8_t
{
    BIG_ENDIANNESS = 0x0,
    LITTLE_ENDIANNESS = 0x1
} Endianness;

static const Endianness DEFAULT_ENDIAN;

Cdr& Cdr::read_encapsulation()
{
    // DDS_CDR: 先读 dummy byte（必须为 0）
    // 再读 encapsulationKind（低 1 位 = 字节序，bit1 = PL 标志）
    // 若字节序与当前不同 → 切换 m_swapBytes
    // DDS_CDR: 再读 m_options (uint16)
    resetAlignment();
    return *this;
}

Cdr& Cdr::serialize_encapsulation()
{
    // DDS_CDR: 写 dummy=0
    // 写 encapsulationKind = m_plFlag | m_endianness
    // DDS_CDR: 写 m_options
    resetAlignment();
    return *this;
}

[ dummy:1B=0 ] [ encapsulationKind:1B ] [ options:2B ]
                  ├ bit0: endianness
                  └ bit1: parameter list flag

inline static size_t alignment(
        size_t current_alignment,
        size_t dataSize)
{
    return (dataSize - (current_alignment % dataSize)) & (dataSize - 1);
}

inline size_t alignment(
        size_t dataSize) const
{
    return dataSize >
           m_lastDataSize ? (dataSize - ((m_currentPosition - m_alignPosition) % dataSize)) &
           (dataSize - 1) : 0;
}

inline void makeAlign(
        size_t align)
{
    m_currentPosition += align;
}

Cdr& Cdr::serialize(
        const int16_t short_t)
{
    size_t align = alignment(sizeof(short_t));
    size_t sizeAligned = sizeof(short_t) + align;

    if (((m_lastPosition - m_currentPosition) >= sizeAligned) || resize(sizeAligned))
    {
        m_lastDataSize = sizeof(short_t);
        makeAlign(align);

        if (m_swapBytes)
        {
            const char* dst = reinterpret_cast<const char*>(&short_t);
            m_currentPosition++ << dst[1];
            m_currentPosition++ << dst[0];
        }
        else
        {
            m_currentPosition << short_t;
            m_currentPosition += sizeof(short_t);
        }
        return *this;
    }
    throw NotEnoughMemoryException(...);
}

FastCdr& serialize(
        const int16_t short_t)
{
    if (((m_lastPosition - m_currentPosition) >= sizeof(short_t)) || resize(sizeof(short_t)))
    {
        m_currentPosition << short_t;
        m_currentPosition += sizeof(short_t);
        return *this;
    }
    throw exception::NotEnoughMemoryException(...);
}

FastCdr& FastCdr::serializeArray(
        const int16_t* short_t,
        size_t numElements)
{
    size_t totalSize = sizeof(*short_t) * numElements;

    if (((m_lastPosition - m_currentPosition) >= totalSize) || resize(totalSize))
    {
        m_currentPosition.memcopy(short_t, totalSize);
        m_currentPosition += totalSize;
        return *this;
    }
    throw NotEnoughMemoryException(...);
}

#define FASTCDR_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
#define FASTCDR_VERSION_MINOR @PROJECT_VERSION_MINOR@
#define FASTCDR_VERSION_MICRO @PROJECT_VERSION_PATCH@
#define FASTCDR_IS_BIG_ENDIAN_TARGET @FASTCDR_IS_BIG_ENDIAN_TARGET@
#define FASTCDR_HAVE_FLOAT128 @FASTCDR_HAVE_FLOAT128@
#define FASTCDR_SIZEOF_LONG_DOUBLE @FASTCDR_SIZEOF_LONG_DOUBLE@

ROS msg 对象
    │
    ▼
rosidl_typesupport_fastrtps_cpp::serialize()
    │
    ├─ FastBuffer(buffer, size)  或  FastBuffer() + reserve
    ├─ Cdr scdr(buffer, DEFAULT_ENDIAN, DDS_CDR)
    ├─ scdr.serialize_encapsulation()
    ├─ msg.serialize(scdr)        // 生成的代码
    │
    ▼
Fast-DDS 将 buffer 作为 Sample payload 发送
    │
    ▼
对端 Cdr dcdr(buffer, ..., DDS_CDR)
    ├─ dcdr.read_encapsulation()
    └─ msg.deserialize(dcdr)

Fast-DDS/
├── include/
│   ├── fastdds/dds/          # 现代 DDS 公开 API（221 个头文件）
│   ├── fastdds/rtps/         # RTPS 公开 API
│   ├── fastrtps/             # Legacy API（201 个头文件）
│   └── dds/                  # OMG PSM 包装（119 个头文件）
├── src/cpp/                  # 全部实现（478 源文件，~20 万行）
│   ├── fastdds/              # DDS 层（~29K 行）
│   ├── rtps/                 # RTPS 核心（~101K 行）★ 最大模块
│   ├── dynamic-types/        # XTypes 动态类型（~35K 行）
│   ├── security/             # 安全插件（~12K 行）
│   ├── statistics/           # 统计模块（可选，~14K 行）
│   ├── fastrtps_deprecated/  # Legacy 实现（~5K 行）
│   ├── dds/                  # PSM 包装（~1.3K 行）
│   └── utils/                # 公共工具
├── test/                     # unittest / blackbox / performance
├── tools/                    # fastdds CLI、discovery server
├── examples/                 # C++ 示例
├── cmake/                    # 构建与打包
├── thirdparty/               # taocpp-pegtl 等
├── CMakeLists.txt
└── package.xml               # ROS 包名 fastrtps

ReturnCode_t DomainParticipantImpl::enable()
{
    assert(rtps_participant_ == nullptr);

    fastrtps::rtps::RTPSParticipantAttributes rtps_attr;
    set_attributes_from_qos(rtps_attr, qos_);
    rtps_attr.participantID = participant_id_;

    RTPSParticipant* part = RTPSDomain::clientServerEnvironmentCreationOverride(...);

    if (part == nullptr)
    {
        part = RTPSDomain::createParticipant(domain_id_, false, rtps_attr, &rtps_listener_);
        // ...
    }

    guid_ = part->getGuid();
    rtps_participant_ = part;

    // autoenable: 依次 enable Topic → Publisher → Subscriber
    if (qos_.entity_factory().autoenable_created_entities) { /* ... */ }

    rtps_participant_->enable();

    return ReturnCode_t::RETCODE_OK;
}

bool DataWriterImpl::write(
        void* data)
{
    if (writer_ == nullptr)
    {
        return false;
    }

    logInfo(DATA_WRITER, "Writing new data");
    return ReturnCode_t::RETCODE_OK == create_new_change(ALIVE, data);
}

DataWriter::write(data)
    → DataWriterImpl::create_new_change()
        → TypeSupport::serialize()  // Fast-CDR
        → WriterHistory 添加 CacheChange
        → RTPSWriter (StatefulWriter/StatelessWriter)
            → FlowController（流控，可选）
            → RTPSMessageGroup 组装 Data 子消息
            → NetworkFactory → Transport 发送

Transport 接收 UDP/SHM 报文
    → MessageReceiver 解析 RTPS 子消息
        → StatefulReader / StatelessReader
            → ReaderHistory 存入 CacheChange
                → DataReaderImpl::read/take()
                    → TypeSupport::deserialize()  // Fast-CDR
                        → 返回给应用 / RMW

bool BuiltinProtocols::initBuiltinProtocols(
        RTPSParticipantImpl* p_part,
        BuiltinAttributes& attributes)
{
    // PDP — 按 discoveryProtocol 选择实现
    switch (m_att.discovery_config.discoveryProtocol)
    {
        case DiscoveryProtocol_t::SIMPLE:
            mp_PDP = new PDPSimple(this, allocation);
            break;
        case DiscoveryProtocol_t::CLIENT:
            mp_PDP = new fastdds::rtps::PDPClient(this, allocation);
            break;
        case DiscoveryProtocol_t::SERVER:
            mp_PDP = new fastdds::rtps::PDPServer(this, allocation, ...);
            break;
        // ...
    }

    mp_PDP->init(mp_participantImpl);

    // WLP — Writer Liveliness Protocol
    if (m_att.use_WriterLivelinessProtocol)
    {
        mp_WLP = new WLP(this);
        mp_WLP->initWL(mp_participantImpl);
    }

    // TypeLookupManager
    if (m_att.typelookup_config.use_client || m_att.typelookup_config.use_server)
    {
        tlm_ = new fastdds::dds::builtin::TypeLookupManager(this);
        tlm_->init_typelookup_service(mp_participantImpl);
    }

    return true;
}

publications_reader_.first->matched_writer_add(*temp_writer_proxy_data);
// ...
publications_writer_.first->matched_reader_add(*temp_reader_proxy_data);
// ...
subscriptions_reader_.first->matched_writer_add(*temp_writer_proxy_data);
// ...
subscriptions_writer_.first->matched_reader_add(*temp_reader_proxy_data);

CacheChange
├── writerGUID / sequenceNumber
├── serializedPayload（Fast-CDR 编码后的字节）
├── instanceHandle
└── kind（ALIVE / NOT_ALIVE_DISPOSED 等）

WriterHistory — _writer 侧变更缓存（发送队列）
ReaderHistory — _reader 侧变更缓存（接收队列）
CacheChangePool — 对象池，减少分配
TopicPayloadPool — payload 内存池（可共享）

MessageReceiver::MessageReceiver(
        RTPSParticipantImpl* participant,
        uint32_t rec_buffer_size)
    : participant_(participant)
    // ...
#if HAVE_SECURITY
    , crypto_msg_(participant->is_secure() ? rec_buffer_size : 0)
    // ...
#endif
{
#if HAVE_SECURITY
    if (participant->is_secure())
    {
        process_data_message_function_ = std::bind(
            &MessageReceiver::process_data_message_with_security, ...);
    }
#endif
}

typedef struct CustomParticipantInfo
{
  eprosima::fastdds::dds::DomainParticipant * participant_{nullptr};
  ParticipantListener * listener_{nullptr};

  eprosima::fastdds::dds::Publisher * publisher_{nullptr};
  eprosima::fastdds::dds::Subscriber * subscriber_{nullptr};

  mutable std::mutex entity_creation_mutex_;
  bool leave_middleware_default_qos;
  publishing_mode_t publishing_mode;
} CustomParticipantInfo;

rclcpp::Publisher::publish(msg)
    → rcl_publish()
        → rmw_publish()                          [rmw_fastrtps_shared_cpp]
            → DataWriter::write(msg)
                → TypeSupport::serialize(msg)     [rosidl_typesupport_fastrtps + Fast-CDR]
                → StatefulWriter::new_change()
                    → RTPSMessageGroup → UDP/SHM
                        ═══════ 网络 / 共享内存 ═══════
                    → MessageReceiver → StatefulReader
                → TypeSupport::deserialize(msg)
            → rmw_take() → rcl_take()
        → rclcpp::Subscription callback

test/
├── unittest/          # 单元测试（rtps/history, transport, security 等）
├── blackbox/          # 端到端通信测试
├── performance/       # 吞吐量/延迟基准
├── communication/       # 多参与者互通
└── system/tools/      # fastdds CLI 测试

┌──────────────────────────────────────────────────────────────┐
│  应用层：ROS 2 (rmw_iceoryx / CycloneDDS-SHM) / 原生 iceoryx  │
└──────────────┬───────────────────────────┬───────────────────┘
               │ C++ API                   │ C API
┌──────────────▼──────────────┐  ┌─────────▼─────────────────┐
│  iceoryx_posh（POSIX SHM）  │◄─┤  iceoryx_binding_c        │
│  Publisher/Subscriber       │  │  iox_pub_* / iox_sub_*    │
│  RouDi · Runtime · WaitSet  │  └───────────────────────────┘
│  mepoo(MemPool/Chunk)·CaPro │
└──────────────┬──────────────┘
               │
┌──────────────▼──────────────────────────────────────────────┐
│  iceoryx_hoofs — 无异常/无堆分配 C++ 基础库                    │
│  cxx 容器 · concurrent 无锁原语 · posix 封装 · relocatable ptr│
└──────────────┬──────────────────────────────────────────────┘
               │
┌──────────────▼──────────────────────────────────────────────┐
│  platform 抽象层（linux/mac/qnx/unix/win）                    │
└──────────────────────────────────────────────────────────────┘

//--------- Communication Resources Start---------------------
// Publisher
constexpr uint32_t MAX_PUBLISHERS = build::IOX_MAX_PUBLISHERS;
constexpr uint32_t MAX_SUBSCRIBERS_PER_PUBLISHER = build::IOX_MAX_SUBSCRIBERS_PER_PUBLISHER;
constexpr uint32_t MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY =
    build::IOX_MAX_CHUNKS_ALLOCATED_PER_PUBLISHER_SIMULTANEOUSLY;
constexpr uint64_t MAX_PUBLISHER_HISTORY = build::IOX_MAX_PUBLISHER_HISTORY;
// Subscriber
constexpr uint32_t MAX_SUBSCRIBERS = build::IOX_MAX_SUBSCRIBERS;
constexpr uint32_t MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY =
    build::IOX_MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY;

private:
  /// @brief string representation of the service
  IdString_t m_serviceString;
  /// @brief string representation of the instance
  IdString_t m_instanceString;
  /// @brief string representation of the event
  IdString_t m_eventString;

  /// @brief 128-Bit class hash (32-Bit * 4)
  ClassHash m_classHash{0, 0, 0, 0};

  /// @brief How far this service should be propagated
  Scope m_scope{Scope::WORLDWIDE};

struct ChunkHeader
{
    using UserPayloadOffset_t = uint32_t;

    /// @brief constructs and initializes a ChunkHeader
    /// @param[in] chunkSize is the size of the chunk the ChunkHeader is constructed
    /// @param[in] chunkSettings are the settings like user-payload size and user-header alignment
    ChunkHeader(const uint32_t chunkSize, const ChunkSettings& chunkSettings) noexcept;

    // copy/move ctors/assignment operators are deleted since the calculations for the user-header and user-payload
    // alignment are dependent on the address of the this pointer
    ChunkHeader(const ChunkHeader&) = delete;
    ChunkHeader(ChunkHeader&&) = delete;

    ChunkHeader& operator=(const ChunkHeader&) = delete;
    ChunkHeader& operator=(ChunkHeader&&) = delete;

    /// @brief From the 1.0 release onward, this must be incremented for each incompatible change, e.g.
    ///            - data width of members changes
    ///            - members are rearranged
    ///            - semantic meaning of a member changes
    static constexpr uint8_t CHUNK_HEADER_VERSION{1U};

class MemPool
{
  public:
    using freeList_t = concurrent::LoFFLi;
    static constexpr uint64_t CHUNK_MEMORY_ALIGNMENT = 8U; // default alignment for 64 bit

    MemPool(const cxx::greater_or_equal<uint32_t, CHUNK_MEMORY_ALIGNMENT> chunkSize,
            const cxx::greater_or_equal<uint32_t, 1> numberOfChunks,
            posix::Allocator& managementAllocator,
            posix::Allocator& chunkMemoryAllocator) noexcept;

enum class IpcMessageType : int32_t
{
    BEGIN = -1,
    NOTYPE = 0,
    REG, // register app
    REG_ACK,
    CREATE_PUBLISHER,
    CREATE_PUBLISHER_ACK,
    CREATE_SUBSCRIBER,
    CREATE_SUBSCRIBER_ACK,
    CREATE_CLIENT,
    CREATE_CLIENT_ACK,
    CREATE_SERVER,
    CREATE_SERVER_ACK,
    CREATE_INTERFACE,
    CREATE_INTERFACE_ACK,
    CREATE_CONDITION_VARIABLE,
    CREATE_CONDITION_VARIABLE_ACK,
    CREATE_NODE,
    CREATE_NODE_ACK,
    KEEPALIVE,
    TERMINATION,
    TERMINATION_ACK,
    PREPARE_APP_TERMINATION,
    PREPARE_APP_TERMINATION_ACK,
    ERROR,
    APP_WAIT,
    WAKEUP_TRIGGER,
    REPLAY,
    MESSAGE_NOT_SUPPORTED,
    // etc..
    END,
};

/// @brief The runtime that is needed for each application to communicate with the RouDi daemon
class PoshRuntime
{
  public:
    PoshRuntime(const PoshRuntime&) = delete;
    PoshRuntime& operator=(const PoshRuntime&) = delete;
    PoshRuntime(PoshRuntime&&) = delete;
    PoshRuntime& operator=(PoshRuntime&&) = delete;
    virtual ~PoshRuntime() noexcept = default;

    /// @brief returns active runtime
    ///
    /// @return active runtime
    static PoshRuntime& getInstance() noexcept;

    /// @brief creates the runtime with given name
    ///
    /// @param[in] name used for registering the process with the RouDi daemon
    ///
    /// @return active runtime
    static PoshRuntime& initRuntime(const RuntimeName_t& name) noexcept;

template <typename... T>
class IOX_NO_DISCARD expected;

/// @brief expected implementation from the C++20 proposal with C++11. The interface
///         is inspired by the proposal but it has changes since we are not allowed to
///         throw an exception.
/// @param ErrorType type of the error which can be stored in the expected
///
/// @code
///     cxx::expected<int, float> callMe() {
///         bool l_errorOccured;
///         // ... do stuff
///         if ( l_errorOccured ) {
///             return cxx::error<float>(55.1f);

template <typename T, uint64_t Capacity>
class vector

template <uint64_t Capacity>
class string

protected:
  using Queue = IndexQueue<Capacity>;
  using BufferIndex = typename Queue::value_t;

  // remark: actually m_freeIndices do not have to be in a queue, it could be another
  // multi-push multi-pop capable lockfree container (e.g. a stack or a list)
  Queue m_freeIndices;

  // required to be a queue for LockFreeQueue to exhibit FIFO behaviour
  Queue m_usedIndices;

  Buffer<ElementType, Capacity, BufferIndex> m_buffer;

  std::atomic<uint64_t> m_size{0u};

/// @brief lockfree queue capable of storing indices 0,1,... Capacity-1
template <uint64_t Capacity, typename ValueType = uint64_t>
class IndexQueue
{

/// @brief
/// Thread safe producer and consumer queue with a safe overflowing behavior.
/// SoFi is designed in a FIFO Manner but prevents data loss when pushing into
/// a full SoFi. When SoFi is full and a Sender tries to push, the data at the
/// current read position will be returned. SoFi is a Thread safe without using
/// locks. When the buffer is filled, new data is written starting at the
/// beginning of the buffer and overwriting the old.The SoFi is especially
/// designed to provide fixed capacity storage. When its capacity is exhausted,
/// newly inserted elements will cause elements either at the beginning
/// to be overwritten.The SoFi only allocates memory when
/// created , capacity can be is adjusted explicitly.
///
/// @param[in] ValueType        DataType to be stored, must be trivially copyable
/// @param[in] CapacityValue    Capacity of the SoFi
template <class ValueType, uint64_t CapacityValue>
class SoFi
{
    static_assert(std::is_trivially_copyable<ValueType>::value, "SoFi can handle only trivially copyable data types");
    /// @brief Check if Atomic integer is lockfree on platform
    /// ATOMIC_INT_LOCK_FREE = 2 - is always lockfree
    /// ATOMIC_INT_LOCK_FREE = 1 - is sometimes lockfree
    /// ATOMIC_INT_LOCK_FREE = 0 - is never lockfree
    static_assert(2 <= ATOMIC_INT_LOCK_FREE, "SoFi is not able to run lock free on this data type");

class LoFFLi
{
  public:
    using Index_t = uint32_t;

  private:
    struct alignas(8) Node
    {
        Index_t indexToNextFreeIndex;
        uint32_t abaCounter;
    };

    static_assert(sizeof(Node) <= 8U,
                  "The size of 'Node' must not exceed 8 bytes in order to be lock-free on 64 bit systems!");

/// @brief The smart_lock class is a wrapping class which can be used to make
///         an arbitrary class threadsafe by wrapping it with the help of the
///         arrow operator.
///         IMPORTANT: If you generate a threadsafe container with smart_lock,
///                     only the container is threadsafe not the containing
///                     elements!
/// @code
///     #include <algorithm>
///     #include <vector>
///     #include "smart_lock.hpp"
///
///     int main() {
///         concurrent::smart_lock<std::vector<int>> threadSafeVector;
///         threadSafeVector->push_back(123);
///         threadSafeVector->push_back(456);
///         threadSafeVector->push_back(789);
///         size_t vectorSize = threadSafeVector->size();
///
///         {
///             auto guardedVector = threadSafeVector.getScopeGuard();
///             auto iter = std::find(guardVector->begin(), guardVector->end(), 456);
///             if (iter != guardVector->end()) guardVector->erase(iter);
///         }
///     }
/// @endcode
template <typename T, typename MutexType = ::std::mutex>
class smart_lock

class SharedMemoryObject : public DesignPattern::Creation<SharedMemoryObject, SharedMemoryObjectError>
{
  public:
    static constexpr void* NO_ADDRESS_HINT = nullptr;
    SharedMemoryObject(const SharedMemoryObject&) = delete;
    SharedMemoryObject& operator=(const SharedMemoryObject&) = delete;
    SharedMemoryObject(SharedMemoryObject&&) noexcept = default;
    SharedMemoryObject& operator=(SharedMemoryObject&&) noexcept = default;
    ~SharedMemoryObject() noexcept = default;

    void* allocate(const uint64_t size, const uint64_t alignment) noexcept;
    void finalizeAllocation() noexcept;

    Allocator* getAllocator() noexcept;
    const void* getBaseAddress() const noexcept;
    void* getBaseAddress() noexcept;

    uint64_t getSizeInBytes() const noexcept;
    int getFileHandle() const noexcept;
    bool hasOwnership() const noexcept;

/// @brief Wrapper class for unix domain socket
class UnixDomainSocket : public DesignPattern::Creation<UnixDomainSocket, IpcChannelError>
{
  public:
    struct NoPathPrefix_t
    {
    };
    static constexpr NoPathPrefix_t NoPathPrefix{};
    static constexpr uint64_t NULL_TERMINATOR_SIZE = 1U;
    static constexpr uint64_t MAX_MESSAGE_SIZE = platform::IOX_UDS_SOCKET_MAX_MESSAGE_SIZE - NULL_TERMINATOR_SIZE;
    /// @brief The name length is limited by the size of the sockaddr_un::sun_path buffer and the IOX_SOCKET_PATH_PREFIX
    static constexpr size_t LONGEST_VALID_NAME = sizeof(sockaddr_un::sun_path) - 1;

    using UdsName_t = cxx::string<LONGEST_VALID_NAME>;
    using Message_t = cxx::string<MAX_MESSAGE_SIZE>;

/// @brief pointer class to use when pointer and pointee are located in different shared memory segments
/// We can have the following scenario:
/// Pointer p is stored in segment S1 and points to object X of type T in segment S2.
///
/// Shared Memory   S1:  p              S2:  X
///                      |___________________^
/// App1            a1   b1             c1   d1
/// App2            a2   b2             c2   d2
///
/// Now it is no longer true in general that both segments will be offset by the same difference in App2 and therefore
/// relocatable pointers are no longer sufficient.
/// Relative pointers solve this problem by incorporating the information from where they need to measure differences
/// (i.e. relative to the given address). This requires an additional registration mechanism to be used by all
/// applications where the start addresses and the size of all segments to be used are registered. Since these start
/// address may differ between applications, each segment is identified by a unique id, which can be provided upon
/// registration by the first application. In the figure, this means that the starting addresses of both segments(a1, a2
/// and c1, c2) would have to be registered in both applications.
/// Once this registration is done, relative pointers can be constructed from raw pointers similar to relocatable
/// pointers.
/// @note It should be noted that relocating a memory segment will invalidate relative pointers, i.e. relative pointers
/// are NOT relocatable. This is because the registration mechanism cannot be automatically informed about the copy of a
/// whole segment, such a segment would have to be registered on its own (and the original segment deregistered).

protected:
  id_t m_id{NULL_POINTER_ID};
  offset_t m_offset{NULL_POINTER_OFFSET};

BaseRelativePointer::offset_t BaseRelativePointer::getOffset(const id_t id, const_ptr_t ptr) noexcept
{
    if (id == NULL_POINTER_ID)
    {
        return NULL_POINTER_OFFSET;
    }
    auto* basePtr = getBasePtr(id);
    return reinterpret_cast<offset_t>(ptr) - reinterpret_cast<offset_t>(basePtr);
}

BaseRelativePointer::ptr_t BaseRelativePointer::getPtr(const id_t id, const offset_t offset) noexcept
{
    if (offset == NULL_POINTER_OFFSET)
    {
        return nullptr;
    }
    auto* basePtr = getBasePtr(id);
    // NOLINTNEXTLINE(performance-no-int-to-ptr) reliance on integers for offset computation by design
    return reinterpret_cast<ptr_t>(offset + reinterpret_cast<offset_t>(basePtr));
}

/// @brief Allows registration of memory segments with their start pointers and size.
/// This class is used to resolve relative pointers in the corresponding address space of the application.
/// Up to CAPACITY segments can be registered with MIN_ID = 1 to MAX_ID = CAPACITY - 1
/// id 0 is reserved and allows relative pointers to behave like normal pointers
/// (which is equivalent to measure the offset relative to 0).
template <typename id_t, typename ptr_t, uint64_t CAPACITY = 10000U>
class PointerRepository
{

/// @brief Smart pointer type that allows objects using it to able to be copied by memcpy
///        without invalidating the pointer.
///        This applies only if it points to memory owned by the object itself
///        (i.e. not to memory outside of the object).
///        This is useful to improve copy-efficiency and allow the types build with relocatable
///        pointers only to be stored in shared memory.
///        It is useable like a raw pointer of the corresponding type and can be implicily
///        converted to one.
///
/// @tparam T the native type wrapped by the relocatable_ptr, i.e. relocatable_ptr<T>
///         has native type T and corresponds to a raw pointer of type T*.
///
/// @note It is advisable to use relocatable_ptr only for storage (e.g. member variables),
///       not to pass them around as function arguments or as return value.
///       There should be no need for this, since as pass-around type
///       regular pointers do the job just fine and do not incur
///       the slight runtime overhead of a relocatable_ptr.
///       There should be no memory overhead on 64 bit systems.
/// @note relocatable_ptr is not trivially copyable since in general the copy constructor
///       requires additional logic. Hence obects that contain it re not trivially
///       copyable in the C++ sense. However, if the pointees of a host object containing the
///       relocatable ptr are all located inside the object and the obect is otherwise trivially
///       copyable it can be safely copied by memcpy.
/// @todo specialize for another pointer class for this use case once it is fully defined/understood
template <typename T>
class relocatable_ptr

RouDi 进程
 ├─ 管理段（iceoryx_mgmt）
 │    ├─ SegmentManager           ← 所有段的元信息，应用通过它查询自己可映射的段
 │    ├─ 各 MemPool 的 LoFFLi 空闲索引表（管理内存）
 │    ├─ ChunkManagement 池（引用计数对象池）
 │    └─ port 数据 / 条件变量等（见 03 篇）
 │
 └─ 用户数据段（每个 [reader组, writer组] 一个，shm 名 = writer 组名）
      ├─ MemPool #0: 128B  × 10000   ┐
      ├─ MemPool #1: 1KB   × 5000    │ 按 chunk 大小递增排列
      ├─ ...                         │ 的 bucket（桶）
      └─ MemPool #6: 4MB   × 10      ┘

template <typename SharedMemoryObjectType, typename MemoryManagerType>
inline MePooSegment<SharedMemoryObjectType, MemoryManagerType>::MePooSegment(
    const MePooConfig& mempoolConfig,
    posix::Allocator& managementAllocator,
    const posix::PosixGroup& readerGroup,
    const posix::PosixGroup& writerGroup,
    const iox::mepoo::MemoryInfo& memoryInfo) noexcept
    : m_sharedMemoryObject(std::move(createSharedMemoryObject(mempoolConfig, writerGroup)))
    , m_readerGroup(readerGroup)
    , m_writerGroup(writerGroup)
    , m_memoryInfo(memoryInfo)
{
    using namespace posix;
    AccessController accessController;
    if (!(readerGroup == writerGroup))
    {
        accessController.addPermissionEntry(
            AccessController::Category::SPECIFIC_GROUP, AccessController::Permission::READ, readerGroup.getName());
    }
    accessController.addPermissionEntry(
        AccessController::Category::SPECIFIC_GROUP, AccessController::Permission::READWRITE, writerGroup.getName());
    ...
    m_memoryManager.configureMemoryManager(mempoolConfig, managementAllocator, *m_sharedMemoryObject.getAllocator());
    m_sharedMemoryObject.finalizeAllocation();
}

template <typename SegmentType>
inline typename SegmentManager<SegmentType>::SegmentMappingContainer
SegmentManager<SegmentType>::getSegmentMappings(const posix::PosixUser& user) noexcept
{
    // get all the groups the user is in
    auto groupContainer = user.getGroups();
    ...
    for (const auto& groupID : groupContainer)
    {
        for (const auto& segment : m_segmentContainer)
        {
            if (segment.getWriterGroup() == groupID)
            {
                // a user is allowed to be only in one writer group, as we currently only support one memory manager per
                // process
                if (!foundInWriterGroup)
                {
                    mappingContainer.emplace_back(segment.getWriterGroup().getName(), ...);
                    foundInWriterGroup = true;
                }
                else
                {
                    errorHandler(Error::kMEPOO__USER_WITH_MORE_THAN_ONE_WRITE_SEGMENT);
                    ...

class MemPool
{
  public:
    using freeList_t = concurrent::LoFFLi;
    static constexpr uint64_t CHUNK_MEMORY_ALIGNMENT = 8U; // default alignment for 64 bit

    MemPool(const cxx::greater_or_equal<uint32_t, CHUNK_MEMORY_ALIGNMENT> chunkSize,
            const cxx::greater_or_equal<uint32_t, 1> numberOfChunks,
            posix::Allocator& managementAllocator,
            posix::Allocator& chunkMemoryAllocator) noexcept;
    ...
    void* getChunk() noexcept;
    ...
    void freeChunk(const void* chunk) noexcept;

  private:
    ...
    rp::RelativePointer<uint8_t> m_rawMemory;

    uint32_t m_chunkSize{0U};
    /// needs to be 32 bit since loffli supports only 32 bit numbers
    /// (cas is only 64 bit and we need the other 32 bit for the aba counter)
    uint32_t m_numberOfChunks{0U};

    std::atomic<uint32_t> m_usedChunks{0U};
    std::atomic<uint32_t> m_minFree{0U};

    freeList_t m_freeIndices;
};

void* MemPool::getChunk() noexcept
{
    uint32_t l_index{0U};
    if (!m_freeIndices.pop(l_index))
    {
        std::cerr << "Mempool [m_chunkSize = " << m_chunkSize << ...
        return nullptr;
    }
    ...
    m_usedChunks.fetch_add(1U, std::memory_order_relaxed);
    adjustMinFree();

    return m_rawMemory + l_index * m_chunkSize;
}

void MemPool::freeChunk(const void* chunk) noexcept
{
    cxx::Expects(m_rawMemory <= chunk
                 && chunk <= m_rawMemory + (static_cast<uint64_t>(m_chunkSize) * (m_numberOfChunks - 1U)));

    auto offset = static_cast<const uint8_t*>(chunk) - m_rawMemory;
    cxx::Expects(offset % m_chunkSize == 0);

    uint32_t index = static_cast<uint32_t>(offset / m_chunkSize);

    if (!m_freeIndices.push(index))
    {
        errorHandler(Error::kPOSH__MEMPOOL_POSSIBLE_DOUBLE_FREE);
    }

    m_usedChunks.fetch_sub(1U, std::memory_order_relaxed);
}

struct alignas(8) Node
{
    Index_t indexToNextFreeIndex;
    uint32_t abaCounter;
};

static_assert(sizeof(Node) <= 8U,
              "The size of 'Node' must not exceed 8 bytes in order to be lock-free on 64 bit systems!");

private:
  // the order of these members must be changed carefully and if this happens, the m_chunkHeaderVersion
  // needs to be adapted in order to be able to detect incompatibilities between publisher/subscriber
  // or record&replay, m_chunkSize and m_chunkHeaderVersion should therefore neither changed the type,
  // nor the position

  // size of the whole chunk, including the header
  uint32_t m_chunkSize{0U};
  uint8_t m_chunkHeaderVersion{CHUNK_HEADER_VERSION};
  // reserved for future functionality and used to indicate the padding bytes; currently not used and set to `0`
  uint8_t m_reserved{0};
  // currently just a placeholder
  uint16_t m_userHeaderId{NO_USER_HEADER};
  popo::UniquePortId m_originId{popo::InvalidPortId};
  uint64_t m_sequenceNumber{0U};
  uint32_t m_userHeaderSize{0U};
  uint32_t m_userPayloadSize{0U};
  uint32_t m_userPayloadAlignment{1U};
  UserPayloadOffset_t m_userPayloadOffset{sizeof(ChunkHeader)};

if (userHeaderSize == 0U)
{
    if (userPayloadAlignment <= alignof(mepoo::ChunkHeader))
    {
        // the most simple case with no user-header and the user-payload adjacent to the ChunkHeader
        m_userPayloadOffset = sizeof(ChunkHeader);
    }
    else
    {
        // the second most simple case with no user-header but the user-payload alignment
        // exceeds the ChunkHeader alignment and is therefore not necessarily adjacent
        uint64_t addressOfChunkHeader = reinterpret_cast<uint64_t>(this);
        uint64_t headerEndAddress = addressOfChunkHeader + sizeof(ChunkHeader);
        uint64_t alignedUserPayloadAddress =
            iox::cxx::align(headerEndAddress, static_cast<uint64_t>(userPayloadAlignment));
        uint64_t offsetToUserPayload = alignedUserPayloadAddress - addressOfChunkHeader;
        ...
        m_userPayloadOffset = static_cast<UserPayloadOffset_t>(offsetToUserPayload);

        // this is safe since the alignment of the user-payload is larger than the one from the ChunkHeader
        ...
        auto addressOfBackOffset = alignedUserPayloadAddress - sizeof(UserPayloadOffset_t);
        auto backOffset = reinterpret_cast<UserPayloadOffset_t*>(addressOfBackOffset);
        *backOffset = m_userPayloadOffset;
    }
}

chunk 起始（8 字节对齐）
┌───────────────────┬──────────────┬─── padding ───┬────────────┬──────────────────┐
│ ChunkHeader (32B) │ user-header  │  (对齐填充)    │ backOffset │   user-payload    │
└───────────────────┴──────────────┴───────────────┴─────4B─────┴──────────────────┘
                     ↑ 总是紧邻 ChunkHeader                       ↑ 按 userPayloadAlignment 对齐

ChunkHeader* ChunkHeader::fromUserPayload(void* const userPayload) noexcept
{
    if (userPayload == nullptr)
    {
        return nullptr;
    }
    uint64_t userPayloadAddress = reinterpret_cast<uint64_t>(userPayload);
    // the back-offset is always stored in front of the user-payload, no matter if a user-header is used or not or if
    // the user-payload has a custom alignment
    auto backOffset = reinterpret_cast<UserPayloadOffset_t*>(userPayloadAddress - sizeof(UserPayloadOffset_t));
    return reinterpret_cast<ChunkHeader*>(userPayloadAddress - *backOffset);
}

struct ChunkManagement
{
    using base_t = ChunkHeader;
    using referenceCounterBase_t = uint64_t;
    using referenceCounter_t = std::atomic<referenceCounterBase_t>;

    ChunkManagement(const cxx::not_null<base_t*> chunkHeader,
                    const cxx::not_null<MemPool*> mempool,
                    const cxx::not_null<MemPool*> chunkManagementPool) noexcept;

    iox::rp::RelativePointer<base_t> m_chunkHeader;
    referenceCounter_t m_referenceCounter{1U};
    /// @todo optimization: check if this can be replaced by an offset relative to the this pointer
    iox::rp::RelativePointer<MemPool> m_mempool;
    iox::rp::RelativePointer<MemPool> m_chunkManagementPool;
};

void SharedChunk::incrementReferenceCounter() noexcept
{
    if (m_chunkManagement != nullptr)
    {
        m_chunkManagement->m_referenceCounter.fetch_add(1U, std::memory_order_relaxed);
    }
}

void SharedChunk::decrementReferenceCounter() noexcept
{
    if ((m_chunkManagement != nullptr)
        && (m_chunkManagement->m_referenceCounter.fetch_sub(1U, std::memory_order_relaxed) == 1U))
    {
        freeChunk();
    }
}

void SharedChunk::freeChunk() noexcept
{
    m_chunkManagement->m_mempool->freeChunk(m_chunkManagement->m_chunkHeader);
    m_chunkManagement->m_chunkManagementPool->freeChunk(m_chunkManagement);
    m_chunkManagement = nullptr;
}

void MemoryManager::configureMemoryManager(const MePooConfig& mePooConfig,
                                           posix::Allocator& managementAllocator,
                                           posix::Allocator& chunkMemoryAllocator) noexcept
{
    for (auto entry : mePooConfig.m_mempoolConfig)
    {
        addMemPool(managementAllocator, chunkMemoryAllocator, entry.m_size, entry.m_chunkCount);
    }

    generateChunkManagementPool(managementAllocator);
}