提高C ++的序列化开销 [英] Boost C++ Serialization overhead

问题描述

我试图衡量以下code

I'm trying to measure serialization overhead with following code

    const int message_size=1000;

    std::vector<short> message(message_size);

    std::string s((char*)(&message[0]), message_size * sizeof(short));

    double size= 1000*sizeof(short);
    double size2= s.size();
    double overhead = size2 - size; //is zero

是不是正确的？ （这是摘自
矢量系列化）

我如何测量序列化的开销？ - 主要的问题是测量序列矢量。
我可以使用加速进行序列化。

How can I measure serialization overhead? - main problem is to measure serialized vector. I can use Boost for serialization.

推荐答案

这个通用测试平台应使您决定：看到它的的住在Coliru

This generic test bed should enable you to decide: see it Live On Coliru

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/fusion/adapted/boost_tuple.hpp>
#include <boost/make_shared.hpp>
#include <boost/phoenix.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/tuple/tuple.hpp>
#include <iostream>
#include <sstream>

namespace detail
{
    struct add_to_archive_f 
    {
        template <typename, typename> struct result { typedef void type; };
        template <typename Archive, typename T> 
            void operator()(Archive& ar, T const& t) const {
                ar << BOOST_SERIALIZATION_NVP(t);
            }
    };

    static const boost::phoenix::function<add_to_archive_f> add_to_archive { };
}

template <typename Archive = boost::archive::binary_oarchive, typename... Data>
size_t archive_size(Data const&... data)
{
    std::ostringstream oss;
    Archive oa(oss);

    boost::fusion::for_each(boost::make_tuple(data...), 
            detail::add_to_archive(
                boost::phoenix::ref(oa), 
                boost::phoenix::arg_names::arg1
                ));

    return oss.str().size();
}

template <typename Archive = boost::archive::binary_oarchive, typename... Data>
void benchmark(Data const&... data)
{
    std::cout << __PRETTY_FUNCTION__ << ":\t" << archive_size<Archive>(data...) << "\n";
}

struct Base {
    boost::array<double, 1000> data;
    virtual ~Base() {}

  private:
    friend class boost::serialization::access;
    template <typename Archive> void serialize(Archive& ar, unsigned /*version*/) {
        ar & BOOST_SERIALIZATION_NVP(data);
    }
};

struct Derived : Base {
    std::string x;
    Derived() : x(1000, '\0') { }

  private:
    friend class boost::serialization::access;
    template <typename Archive> void serialize(Archive& ar, unsigned /*version*/) {
        ar & boost::serialization::make_nvp("base", boost::serialization::base_object<Base>(*this));
        ar & BOOST_SERIALIZATION_NVP(x);
    }
};

测试驱动程序：

template <typename Archive> 
void some_scenarios()
{
    benchmark<Archive>(std::vector<char>(1000));
    benchmark<Archive>(boost::make_shared<std::vector<char>>(1000));
    benchmark<Archive>(3.14f, 42, 42ull, "hello world");
    benchmark<Archive>(boost::make_shared<Base>());
    benchmark<Archive>(boost::make_shared<Derived>());
}

int main()
{
    some_scenarios<boost::archive::binary_oarchive>();
    some_scenarios<boost::archive::text_oarchive>();
    some_scenarios<boost::archive::xml_oarchive>();
}

在我的64位的Ubuntu的输出与升压1.55：

The output on my 64-bit Ubuntu with Boost 1.55:

void benchmark(const Data& ...) [with Archive = boost::archive::binary_oarchive; Data = {std::vector<char, std::allocator<char> >}]:    1052
void benchmark(const Data& ...) [with Archive = boost::archive::binary_oarchive; Data = {boost::shared_ptr<std::vector<char, std::allocator<char> > >}]:    1059
void benchmark(const Data& ...) [with Archive = boost::archive::binary_oarchive; Data = {float, int, long long unsigned int, char [12]}]:   76
void benchmark(const Data& ...) [with Archive = boost::archive::binary_oarchive; Data = {boost::shared_ptr<Base>}]: 8069
void benchmark(const Data& ...) [with Archive = boost::archive::binary_oarchive; Data = {boost::shared_ptr<Derived>}]:  9086
void benchmark(const Data& ...) [with Archive = boost::archive::text_oarchive; Data = {std::vector<char, std::allocator<char> >}]:  2037
void benchmark(const Data& ...) [with Archive = boost::archive::text_oarchive; Data = {boost::shared_ptr<std::vector<char, std::allocator<char> > >}]:  2043
void benchmark(const Data& ...) [with Archive = boost::archive::text_oarchive; Data = {float, int, long long unsigned int, char [12]}]: 92
void benchmark(const Data& ...) [with Archive = boost::archive::text_oarchive; Data = {boost::shared_ptr<Base>}]:   2049
void benchmark(const Data& ...) [with Archive = boost::archive::text_oarchive; Data = {boost::shared_ptr<Derived>}]:    3083
void benchmark(const Data& ...) [with Archive = boost::archive::xml_oarchive; Data = {std::vector<char, std::allocator<char> >}]:   16235
void benchmark(const Data& ...) [with Archive = boost::archive::xml_oarchive; Data = {boost::shared_ptr<std::vector<char, std::allocator<char> > >}]:   17307
void benchmark(const Data& ...) [with Archive = boost::archive::xml_oarchive; Data = {float, int, long long unsigned int, char [12]}]:  436
void benchmark(const Data& ...) [with Archive = boost::archive::xml_oarchive; Data = {boost::shared_ptr<Base>}]:    19393
void benchmark(const Data& ...) [with Archive = boost::archive::xml_oarchive; Data = {boost::shared_ptr<Derived>}]: 21508

正如你所看到的，

As you can see, the

• 开销XML是相当


• 二进制，开销成为小档案不同（例如多态）小各类
的许多元素显著

• overhead for XML is considerable
• for binary, the overhead becomes significant for small archives many elements of differing (e.g. polymorphic) small types

这篇关于提高C ++的序列化开销的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！