c++ - Protobuf vs Flatbuffers vs Cap'n proto哪个更快？

Question

我决定找出 Protobuf、Flatbuffers 和 Cap'n proto 中哪一个是我的应用程序最好/最快的序列化。在我的情况下，通过网络发送某种字节/字符数组(我序列化为该格式的原因)。所以我为所有三个都做了简单的实现，我对一个字符串、一个浮点数和一个整数进行了序列化和反序列化。这给出了意想不到的结果:Protobuf 是最快的。我会称它们为意外，因为 cap'n proto 和 flatbuffes “声称”是更快的选择。在我接受这一点之前，我想看看我是否无意中在我的代码中作弊。如果我没有作弊，我想知道为什么 protobuf 更快(确切地说为什么可能是不可能的)。这些消息能否让 cap'n proto 和 faltbuffers 真正让它们发光发热？

我的时间 :

flatbuffers 耗时:14162 微秒
耗时 capnp:60259 微秒
protobuf 耗时:12131 微秒
(显然这些取决于我的机器，但重要的是相对时间)

FlatBuffers 代码 :

int main (int argc, char *argv[]){
    std::string s = "string";
    float f = 3.14;
    int i = 1337;

    std::string s_r;
    float f_r;
    int i_r;
    flatbuffers::FlatBufferBuilder message_sender;

    int steps = 10000;
    auto start = high_resolution_clock::now(); 
    for (int j = 0; j < steps; j++){
        auto autostring =  message_sender.CreateString(s);
        auto encoded_message = CreateTestmessage(message_sender, autostring, f, i);
        message_sender.Finish(encoded_message);
        uint8_t *buf = message_sender.GetBufferPointer();
        int size = message_sender.GetSize();
        message_sender.Clear();
        //Send stuffs
        //Receive stuffs
        auto recieved_message = GetTestmessage(buf);

        s_r = recieved_message->string_()->str();
        f_r = recieved_message->float_();
        i_r = recieved_message->int_(); 
    }
    auto stop = high_resolution_clock::now(); 
    auto duration = duration_cast<microseconds>(stop - start); 
    cout << "Time taken flatbuffer: " << duration.count() << " microseconds" << endl;
    return 0;
}

cap'n 原型(prototype)代码 :

int main (int argc, char *argv[]){
    char s[] = "string";
    float f = 3.14;
    int i = 1337;

    const char * s_r;
    float f_r;
    int i_r;
    ::capnp::MallocMessageBuilder message_builder;
    Testmessage::Builder message = message_builder.initRoot<Testmessage>();

    int steps = 10000;
    auto start = high_resolution_clock::now(); 
    for (int j = 0; j < steps; j++){  
        //Encodeing
        message.setString(s);
        message.setFloat(f);
        message.setInt(i);

        kj::Array<capnp::word> encoded_array = capnp::messageToFlatArray(message_builder);
        kj::ArrayPtr<char> encoded_array_ptr = encoded_array.asChars();
        char * encoded_char_array = encoded_array_ptr.begin();
        size_t size = encoded_array_ptr.size();
        //Send stuffs
        //Receive stuffs

        //Decodeing
        kj::ArrayPtr<capnp::word> received_array = kj::ArrayPtr<capnp::word>(reinterpret_cast<capnp::word*>(encoded_char_array), size/sizeof(capnp::word));
        ::capnp::FlatArrayMessageReader message_receiver_builder(received_array);
        Testmessage::Reader message_receiver = message_receiver_builder.getRoot<Testmessage>();
        s_r = message_receiver.getString().cStr();
        f_r = message_receiver.getFloat();
        i_r = message_receiver.getInt();
    }
    auto stop = high_resolution_clock::now(); 
    auto duration = duration_cast<microseconds>(stop - start); 
    cout << "Time taken capnp: " << duration.count() << " microseconds" << endl;
    return 0;

}

protobuf 代码 :

int main (int argc, char *argv[]){
    std::string s = "string";
    float f = 3.14;
    int i = 1337;

    std::string s_r;
    float f_r;
    int i_r;
    Testmessage message_sender;
    Testmessage message_receiver;
    int steps = 10000;
    auto start = high_resolution_clock::now(); 
    for (int j = 0; j < steps; j++){
        message_sender.set_string(s);
        message_sender.set_float_m(f);
        message_sender.set_int_m(i);
        int len = message_sender.ByteSize();
        char encoded_message[len];
        message_sender.SerializeToArray(encoded_message, len);
        message_sender.Clear();

        //Send stuffs
        //Receive stuffs
        message_receiver.ParseFromArray(encoded_message, len);
        s_r = message_receiver.string();
        f_r = message_receiver.float_m();
        i_r = message_receiver.int_m();
        message_receiver.Clear();

    }
    auto stop = high_resolution_clock::now(); 
    auto duration = duration_cast<microseconds>(stop - start); 
    cout << "Time taken protobuf: " << duration.count() << " microseconds" << endl;
    return 0;
}

不包括消息定义文件，因为它们很简单并且很可能与它无关。

Answer 1

在 Cap'n Proto 中，您不应重复使用 MessageBuilder对于多条消息。按照您编写代码的方式，循环的每次迭代都会使消息更大，因为您实际上是在添加现有消息而不是开始新消息。为避免每次迭代都分配内存，您应该将暂存缓冲区传递给 MallocMessageBuilder。的构造函数。暂存缓冲区可以在循环外分配一次，但您需要创建一个新的 MallocMessageBuilder每次循环。 (当然，大多数人不关心暂存缓冲区，只是让 MallocMessageBuilder 自己分配，但如果您在此基准测试中选择该路径，那么您还应该更改 Protobuf 基准测试，为每个迭代而不是重用单个对象。)

此外，您的 Cap'n Proto 代码正在使用 capnp::messageToFlatArray() ，它分配一个全新的缓冲区来将消息放入并复制整个消息。这不是使用 Cap'n Proto 的最有效方式。通常，如果您将消息写入文件或套接字，您将直接从消息的原始后备缓冲区写入，而无需制作此拷贝。尝试这样做:

kj::ArrayPtr<const kj::ArrayPtr<const capnp::word>> segments =
    message_builder.getSegmentsForOutput();

// Send segments
// Receive segments

capnp::SegmentArrayMessageReader message_receiver_builder(segments);

或者，为了让事情更真实，您可以使用 capnp::writeMessageToFd() 将消息写出到管道并重新读入。和 capnp::StreamFdMessageReader . (公平地说，您还需要使 protobuf 基准测试写入/读取管道。)

(我是 Cap'n Proto 和 Protobuf v2 的作者。我对 FlatBuffers 不熟悉，所以我无法评论该代码是否有任何类似的问题......)

关于基准

我花了很多时间对 Protobuf 和 Cap'n Proto 进行基准测试。我在此过程中学到的一件事是，您可以创建的最简单的基准测试不会给您带来实际的结果。

首先，任何序列化格式(甚至 JSON)都可以在正确的基准案例中“获胜”。根据内容的不同，不同格式的表现会非常非常不同。它是重字符串、重数字还是重对象(即使用深度消息树)？不同的格式在这里有不同的优势(例如，Cap'n Proto 非常擅长数字，因为它根本不转换它们；JSON 非常不擅长它们)。您的消息大小是非常短、中等长度还是非常大？短消息将主要执行设置/拆卸代码而不是正文处理(但设置/拆卸很重要——有时现实世界的用例涉及大量小消息!)。非常大的消息会破坏 L1/L2/L3 缓存，并告诉您更多关于内存带宽的信息，而不是解析复杂性(但同样，这很重要——某些实现比其他实现更适合缓存)。

即使考虑了所有这些，您还有另一个问题:在循环中运行代码实际上并不能告诉您它在现实世界中的执行情况。当在紧密循环中运行时，指令缓存会保持热状态，并且所有分支都变得高度可预测。因此，分支繁重的序列化(如 protobuf)的分支成本将被掩盖，而代码占用量大的序列化(再次......如 protobuf)也将获得优势。这就是为什么微基准仅在将代码与自身的其他版本进行比较时才真正有用(例如，测试小的优化)，而不是将完全不同的代码库相互比较。要了解这些在现实世界中的表现如何，您需要端到端地衡量现实世界的用例。但是……说实话，这很难。很少有人有时间基于两种不同的序列化构建整个应用程序的两个版本，看看哪一个会胜出……