如何高性能地向通用接口提交任意大小及字段的消息？

问题背景 #

现有一个处理不同类型消息的接口，当前采用枚举标记消息类型+联合体存储消息数据的实现，但存在以下痛点：

• 原生联合体无法自动处理非平凡类型（如std::promise）的初始化与销毁，自定义构造/析构函数会破坏便捷的指定初始化语法
• 改用std::variant可解决生命周期问题，但std::visit带来的性能开销无法接受（代码处于多线程调用的性能瓶颈区）

当前实现代码：

#include <iostream>

enum class MsgType
{
    write,
    read,
    reg_channel,
    unreg_channel,
};

struct Message
{
   MsgType type;
   union
   {
        struct
        {
            void* addr;
            size_t count;
        } write;
        struct
        {
            void* addr;
            size_t count;
        } read;
        struct
        {
            int fd;
            void* addr;
            size_t count;
        } reg_channel;
        struct
        {
            int fd;
        } unreg_channel;
   }; 
};

struct SomeInterface
{
    auto submit(Message& cmd)
    {
        switch(cmd.type)
        {
            case MsgType::write:
                std::cout << "write command submitted" << std::endl;
                break;
            case MsgType::read:
                std::cout << "read command submitted" << std::endl;
                break;
            case MsgType::reg_channel:
                std::cout << "reg_channel command submitted" << std::endl;
                break;
            case MsgType::unreg_channel:
                std::cout << "unreg_channel command submitted" << std::endl;
                break;
            default:
                break;

        }
    }
};

int main()
{
    SomeInterface iface;

    std::byte b;
    auto cmd = Message{
        .type = MsgType::write,
        .write = {
            .addr = &b,
            .count = 1024,
        },
    };
    iface.submit(cmd);
}

方案一：手动管理的类型安全联合体 #

核心思路是保留原生联合体的性能优势，手动为非平凡类型添加构造/销毁逻辑，同时通过推导构造函数保留初始化便捷性。

实现代码 #

#include <iostream>
#include <future>
#include <cstdlib>

enum class MsgType
{
    write,
    read,
    reg_channel,
    unreg_channel,
    write_with_promise,
};

// 独立定义各消息数据结构
struct WriteMsg { void* addr; size_t count; };
struct ReadMsg { void* addr; size_t count; };
struct RegChannelMsg { int fd; void* addr; size_t count; };
struct UnregChannelMsg { int fd; };
struct WriteWithPromiseMsg { void* addr; size_t count; std::promise<int> result; };

struct Message
{
    MsgType type;
    union Data
    {
        WriteMsg write;
        ReadMsg read;
        RegChannelMsg reg_channel;
        UnregChannelMsg unreg_channel;
        WriteWithPromiseMsg write_with_promise;

        Data() = default;
        ~Data() {} // 空析构，手动在Message析构中处理
    } data;

    // 推导构造函数，支持结构化初始化
    template<typename T>
    Message(MsgType t, T&& msg) : type(t)
    {
        if constexpr (std::is_same_v<std::decay_t<T>, WriteMsg>)
            new (&data.write) WriteMsg(std::forward<T>(msg));
        else if constexpr (std::is_same_v<std::decay_t<T>, ReadMsg>)
            new (&data.read) ReadMsg(std::forward<T>(msg));
        else if constexpr (std::is_same_v<std::decay_t<T>, RegChannelMsg>)
            new (&data.reg_channel) RegChannelMsg(std::forward<T>(msg));
        else if constexpr (std::is_same_v<std::decay_t<T>, UnregChannelMsg>)
            new (&data.unreg_channel) UnregChannelMsg(std::forward<T>(msg));
        else if constexpr (std::is_same_v<std::decay_t<T>, WriteWithPromiseMsg>)
            new (&data.write_with_promise) WriteWithPromiseMsg(std::forward<T>(msg));
    }

    // 自定义析构，根据type销毁对应非平凡成员
    ~Message()
    {
        switch(type)
        {
            case MsgType::write_with_promise:
                data.write_with_promise.~WriteWithPromiseMsg();
                break;
            // 平凡类型无需手动销毁，其他case可省略
            default:
                break;
        }
    }

    // 禁用拷贝（非平凡成员拷贝不安全）
    Message(const Message&) = delete;
    Message& operator=(const Message&) = delete;

    // 移动构造实现
    Message(Message&& other) noexcept : type(other.type)
    {
        switch(type)
        {
            case MsgType::write:
                new (&data.write) WriteMsg(std::move(other.data.write));
                break;
            case MsgType::read:
                new (&data.read) ReadMsg(std::move(other.data.read));
                break;
            case MsgType::reg_channel:
                new (&data.reg_channel) RegChannelMsg(std::move(other.data.reg_channel));
                break;
            case MsgType::unreg_channel:
                new (&data.unreg_channel) UnregChannelMsg(std::move(other.data.unreg_channel));
                break;
            case MsgType::write_with_promise:
                new (&data.write_with_promise) WriteWithPromiseMsg(std::move(other.data.write_with_promise));
                other.type = static_cast<MsgType>(-1); // 标记原对象无效，避免重复析构
                break;
            default:
                break;
        }
    }
};

struct SomeInterface
{
    auto submit(Message&& cmd)
    {
        switch(cmd.type)
        {
            case MsgType::write:
                std::cout << "write command submitted" << std::endl;
                break;
            case MsgType::read:
                std::cout << "read command submitted" << std::endl;
                break;
            case MsgType::reg_channel:
                std::cout << "reg_channel command submitted" << std::endl;
                break;
            case MsgType::unreg_channel:
                std::cout << "unreg_channel command submitted" << std::endl;
                break;
            case MsgType::write_with_promise:
                std::cout << "write_with_promise command submitted" << std::endl;
                cmd.data.write_with_promise.result.set_value(0);
                break;
            default:
                break;
        }
    }
};

int main()
{
    SomeInterface iface;

    std::byte b;
    // 保留指定初始化的便捷性
    iface.submit(Message{MsgType::write, WriteMsg{.addr = &b, .count = 1024}});

    // 测试带promise的消息
    auto promise_msg = Message{MsgType::write_with_promise, 
        WriteWithPromiseMsg{.addr = &b, .count = 2048, .result = std::promise<int>{}}};
    auto future = promise_msg.data.write_with_promise.result.get_future();
    iface.submit(std::move(promise_msg));
    std::cout << "Promise result: " << future.get() << std::endl;
}

方案优势 #

• 性能接近原生union+switch：无std::visit额外开销，switch分支可被编译器优化为跳转表
• 自动管理非平凡类型生命周期：析构函数根据type手动调用对应成员的析构函数
• 保留便捷初始化：通过推导构造函数支持结构化绑定风格的初始化
• 可扩展性：新增消息类型只需添加结构体、枚举值，补充构造/析构/switch分支

方案二：模板生成的安全联合体封装 #

如果消息类型较多，可通过模板自动生成安全的union封装，减少重复代码。

核心封装代码 #

#include <iostream>
#include <future>
#include <tuple>
#include <type_traits>

// 模板工具：绑定消息类型与枚举值
template<typename T> struct MsgTypeTag;

enum class MsgType
{
    write,
    read,
    reg_channel,
    unreg_channel,
    write_with_promise,
};

struct WriteMsg { void* addr; size_t count; };
struct ReadMsg { void* addr; size_t count; };
struct RegChannelMsg { int fd; void* addr; size_t count; };
struct UnregChannelMsg { int fd; };
struct WriteWithPromiseMsg { void* addr; size_t count; std::promise<int> result; };

// 特化类型标签
template<> struct MsgTypeTag<WriteMsg> { static constexpr MsgType value = MsgType::write; };
template<> struct MsgTypeTag<ReadMsg> { static constexpr MsgType value = MsgType::read; };
template<> struct MsgTypeTag<RegChannelMsg> { static constexpr MsgType value = MsgType::reg_channel; };
template<> struct MsgTypeTag<UnregChannelMsg> { static constexpr MsgType value = MsgType::unreg_channel; };
template<> struct MsgTypeTag<WriteWithPromiseMsg> { static constexpr MsgType value = MsgType::write_with_promise; };

// 安全联合体模板封装
template<typename... Msgs>
struct SafeUnion
{
    MsgType type;
    union Data
    {
        Data() = default;
        ~Data() {}
        std::tuple<Msgs...> dummy; // 自动推导union的大小与对齐
        Msgs... msgs;
    } data;

    // 从消息对象自动推导类型构造
    template<typename Msg>
    SafeUnion(Msg&& msg) : type(MsgTypeTag<std::decay_t<Msg>>::value)
    {
        new (&get<Msg>()) Msg(std::forward<Msg>(msg));
    }

    // 获取对应类型的引用
    template<typename Msg>
    Msg& get() { return std::get<Msg>(data.msgs); }
    template<typename Msg>
    const Msg& get() const { return std::get<Msg>(data.msgs); }

    // 自动匹配类型销毁
    ~SafeUnion()
    {
        auto destroy = [this]<typename Msg>(Msg*)
        {
            if (type == MsgTypeTag<Msg>::value)
                get<Msg>().~Msg();
        };
        (destroy(static_cast<Msg*>(nullptr)), ...);
    }

    // 禁用拷贝，实现移动构造
    SafeUnion(const SafeUnion&) = delete;
    SafeUnion& operator=(const SafeUnion&) = delete;

    SafeUnion(SafeUnion&& other) noexcept : type(other.type)
    {
        auto move_construct = [this, &other]<typename Msg>(Msg*)
        {
            if (type == MsgTypeTag<Msg>::value)
            {
                new (&get<Msg>()) Msg(std::move(other.get<Msg>()));
                other.type = static_cast<MsgType>(-1);
            }
        };
        (move_construct(static_cast<Msg*>(nullptr)), ...);
    }
};

// 定义最终的Message类型
using Message = SafeUnion<WriteMsg, ReadMsg, RegChannelMsg, UnregChannelMsg, WriteWithPromiseMsg>;

struct SomeInterface
{
    auto submit(Message&& cmd)
    {
        switch(cmd.type)
        {
            case MsgType::write:
                std::cout << "write command submitted" << std::endl;
                break;
            case MsgType::read:
                std::cout << "read command submitted" << std::endl;
                break;
            case MsgType::reg_channel:
                std::cout << "reg_channel command submitted" << std::endl;
                break;
            case MsgType::unreg_channel:
                std::cout << "unreg_channel command submitted" << std::endl;
                break;
            case MsgType::write_with_promise:
                std::cout << "write_with_promise command submitted" << std::endl;
                cmd.get<WriteWithPromiseMsg>().result.set_value(0);
                break;
            default:
                break;
        }
    }
};

int main()
{
    SomeInterface iface;

    std::byte b;
    // 自动推导消息类型，初始化更简洁
    iface.submit(WriteMsg{.addr = &b, .count = 1024});
    iface.submit(WriteWithPromiseMsg{.addr = &b, .count = 2048, .result = std::promise<int>{}});
}

方案优势 #

• 代码复用性高：新增消息类型只需添加结构体、特化MsgTypeTag，无需修改封装逻辑
• 初始化更简洁：可直接传入消息对象，自动推导类型和枚举值
• 性能接近原生union：编译器可优化switch分支，无额外运行时开销

关键注意事项 #

• 拷贝与移动：包含非平凡类型的union无法安全拷贝，需手动实现拷贝逻辑（若需要），或仅支持移动语义
• 类型安全：确保MsgType与消息类型严格对应，避免switch分支遗漏导致的未定义行为
• 编译器优化：开启O2/O3优化后，switch分支会被编译器优化为跳转表，性能与原生union无差异

内容的提问来源于stack exchange，提问作者glades