// (C) Copyright 2007 Kim Barrett - kab@irobot.com
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Example code for measuring the impact of archive_cast patch.
// Compile, link, and run this program against release-mode
// multi-threaded shared-libs builds of boost, with and without the
// archive_cast patch, and compare the timings.
//
// Using gcc 4.3.2, T(patched) is about 3/4 T(unpatched) in my tests.
// Replace "<LOCATION>" with patched / unpatched boost root
//  bjam toolset=gcc
//       variant=release
//       threading=multi
//       link=shared
//       --prefix=<LOCATION>
//       --build-dir=<LOCATION>/build
//       --layout=system
//       install
//  export LD_LIBRARY_PATH=<LOCATION>/lib
//  g++ -Wall -O3 -fPIC -pthread -DNDEBUG
//    -I<LOCATION>/include -L<LOCATION>/lib 
//    -o <LOCATION>/measure-archive-cast measure-archive-cast.cpp
//    -lboost_serialization-mt -lpthread

#include <iostream>
#include <iomanip>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/polymorphic_binary_oarchive.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/timer.hpp>

namespace {

struct Limits {
    float minV;
    float maxV;
    float minA;
    float maxA;
    float minT;
    float maxT;
    double minAP;
    double maxAP;

    Limits() : minV(0.0), maxV(0.0), minA(0.0), maxA(0.0),
               minT(0.0), maxT(0.0), minAP(0.0), maxAP(0.0) {
    }

    template<typename Archive>
    void serialize(Archive& ar, unsigned int /* version */) {
        ar & BOOST_SERIALIZATION_NVP(minV);
        ar & BOOST_SERIALIZATION_NVP(maxV);
        ar & BOOST_SERIALIZATION_NVP(minA);
        ar & BOOST_SERIALIZATION_NVP(maxA);
        ar & BOOST_SERIALIZATION_NVP(minT);
        ar & BOOST_SERIALIZATION_NVP(maxT);
        ar & BOOST_SERIALIZATION_NVP(minAP);
        ar & BOOST_SERIALIZATION_NVP(maxAP);
    }
};

struct AState {
    double p;
    float v;
    float a;
    float t;
    double ap;
    double psd;
    double vsd;
    double asd;
    unsigned long tsh;
    unsigned long tsl;
    Limits limits;

    bool enabled;

    AState() : p(0.0), v(0.0), a(0.0), t(0.0), ap(0.0),
               psd(0.0), vsd(0.0), asd(0.0), limits(), enabled(false) {
    }

    template<typename Archive>
    void serialize(Archive& ar, unsigned int /* version */) {
        ar & BOOST_SERIALIZATION_NVP(p);
        ar & BOOST_SERIALIZATION_NVP(v);
        ar & BOOST_SERIALIZATION_NVP(a);
        ar & BOOST_SERIALIZATION_NVP(t);
        ar & BOOST_SERIALIZATION_NVP(ap);
        ar & BOOST_SERIALIZATION_NVP(psd);
        ar & BOOST_SERIALIZATION_NVP(vsd);
        ar & BOOST_SERIALIZATION_NVP(asd);
        ar & BOOST_SERIALIZATION_NVP(tsh);
        ar & BOOST_SERIALIZATION_NVP(tsl);
        ar & BOOST_SERIALIZATION_NVP(limits);
        ar & BOOST_SERIALIZATION_NVP(enabled);
    }
};

struct MState {
    AState state;
    float v;
    float c;
    float ct;
    float at;
    float dt;

    MState() : state(), v(0.0), c(0.0), ct(0.0), at(0.0), dt(0.0) { }

    template<typename Archive>
    void serialize(Archive& ar, unsigned int /* version */) {
        ar & BOOST_SERIALIZATION_NVP(state);
        ar & BOOST_SERIALIZATION_NVP(v);
        ar & BOOST_SERIALIZATION_NVP(c);
        ar & BOOST_SERIALIZATION_NVP(ct);
        ar & BOOST_SERIALIZATION_NVP(at);
        ar & BOOST_SERIALIZATION_NVP(dt);
    }        
};

}

static const size_t nstates = 1000000;
static const size_t bufferSize = 1000 + nstates * sizeof(MState);
static char buffer[bufferSize];

int main(int argc, char* argv[]) {
    MState data;
    boost::iostreams::stream<boost::iostreams::array_sink> outs(
        buffer,
        bufferSize);
    boost::timer t;
    {
        boost::archive::polymorphic_binary_oarchive bar(
            outs,
            boost::archive::no_header | boost::archive::no_codecvt);
        boost::archive::polymorphic_oarchive& ar = bar;
        t.restart();
        for (size_t i = 0; i < nstates; ++i) {
            ar << boost::serialization::make_nvp("value", data);
        }
    } // run archive destructor to finish archive
    outs.flush();
    double dt = t.elapsed();
    std::cout << "Wrote "
              << nstates << " values of size " << sizeof(MState) << ", "
              << outs.tellp() << " bytes, "
              << dt << " seconds"
              << std::endl;
    return 0;
}