Boost C++ Serialization overhead
Solution 1:
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);
}
};
Test driver:
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>();
}
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
- overhead for XML is considerable
- for binary, the overhead becomes significant for small archives many elements of differing (e.g. polymorphic) small types