| /* /libs/serialization/xml_performance/macro.hpp ******************************* |
| |
| (C) Copyright 2010 Bryce Lelbach |
| |
| 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) |
| |
| *******************************************************************************/ |
| |
| #if !defined(BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP) |
| #define BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| #pragma once |
| #endif |
| |
| #include <boost/preprocessor.hpp> |
| |
| #if !defined(BSL_NODE_MAX) |
| #define BSL_NODE_MAX 4 |
| #endif |
| |
| #if !defined(BSL_DEPTH) |
| #define BSL_DEPTH 2 |
| #endif |
| |
| #if !defined(BSL_ROUNDS) |
| #define BSL_ROUNDS 256 |
| #endif |
| |
| #if !defined(BSL_TYPE) |
| #define BSL_TYPE int |
| #endif |
| |
| #if !defined(BSL_SAVE_TMPFILE) |
| #define BSL_SAVE_TMPFILE 0 |
| #endif |
| |
| #if !defined(BSL_RESULTS_FILE) |
| #define BSL_RESULTS_FILE \ |
| BOOST_PP_STRINGIZE(BSL_TYPE) \ |
| BOOST_PP_STRINGIZE(BSL_EXP(BSL_NODE_MAX, BSL_DEPTH)) \ |
| "_results.xml" \ |
| /**/ |
| #endif |
| |
| // utility print macro |
| |
| #define BSL_PRINT(Z, N, T) T |
| |
| // preprocessor power function, BSL_EXP |
| |
| #define BSL_EXP_PRED(B, D) BOOST_PP_TUPLE_ELEM(3, 0, D) |
| |
| #define BSL_EXP_OP(B, D) \ |
| ( \ |
| BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3, 0, D)), \ |
| BOOST_PP_TUPLE_ELEM(3, 1, D), \ |
| BOOST_PP_MUL_D( \ |
| B, \ |
| BOOST_PP_TUPLE_ELEM(3, 2, D), \ |
| BOOST_PP_TUPLE_ELEM(3, 1, D) \ |
| ) \ |
| ) \ |
| /**/ |
| |
| #define BSL_EXP(X, N) \ |
| BOOST_PP_TUPLE_ELEM( \ |
| 3, 2, BOOST_PP_WHILE(BSL_EXP_PRED, BSL_EXP_OP, (N, X, 1)) \ |
| ) \ |
| /**/ |
| |
| // boost::archive::xml::node macros |
| |
| #define BSL_NODE_DECL_MEMBER(Z, N, _) T ## N element ## N ; |
| #define BSL_NODE_DECL_NONE(Z, N, _) unused_type element ## N ; |
| #define BSL_NODE_xDECL_CTOR() node (void) { } |
| |
| #define BSL_NODE_DECL_CTOR(P) \ |
| BOOST_PP_IF(P, \ |
| BSL_NODE_xDECL_CTOR, \ |
| BOOST_PP_EMPTY \ |
| )() \ |
| /**/ |
| |
| #define BSL_NODE_SERIALIZE(Z, N, _) \ |
| & BOOST_SERIALIZATION_NVP(BOOST_PP_CAT(element, N)) \ |
| /**/ |
| |
| #define BSL_NODE_INIT_LIST(Z, N, _) \ |
| BOOST_PP_COMMA_IF(N) BOOST_PP_CAT(element, N) \ |
| BOOST_PP_LPAREN() BOOST_PP_CAT(p, N) BOOST_PP_RPAREN() \ |
| /**/ |
| |
| #define BSL_NODE_DECL(Z, N, _) \ |
| template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename T)> \ |
| struct node< \ |
| BOOST_PP_ENUM_PARAMS_Z(Z, N, T) \ |
| BOOST_PP_COMMA_IF(N) \ |
| BOOST_PP_ENUM_ ## Z(BOOST_PP_SUB(BSL_NODE_MAX, N), BSL_PRINT, unused_type) \ |
| > { \ |
| BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_DECL_MEMBER, _) \ |
| \ |
| BOOST_PP_REPEAT_FROM_TO_ ## Z(N, BSL_NODE_MAX, BSL_NODE_DECL_NONE, _) \ |
| \ |
| template<class ARC> \ |
| void serialize (ARC& ar, const unsigned int) { \ |
| ar BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_SERIALIZE, _); \ |
| } \ |
| \ |
| BSL_NODE_DECL_CTOR(N) \ |
| \ |
| node (BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, T, p)): \ |
| BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_INIT_LIST, _) { } \ |
| }; \ |
| /**/ |
| |
| // instantiation macros |
| |
| #define BSL_INST_BASE(Z, N, L) \ |
| T0 T0 ## _ ## N(BOOST_PP_ENUM_ ## Z( \ |
| BSL_NODE_MAX, BSL_PRINT, \ |
| boost::archive::xml::random<BSL_TYPE> BOOST_PP_LPAREN() BOOST_PP_RPAREN() \ |
| )); \ |
| /**/ |
| |
| #define BSL_INST_yNODES(Z, N, L) \ |
| BOOST_PP_COMMA_IF(N) \ |
| BOOST_PP_CAT(T, \ |
| BOOST_PP_CAT(BOOST_PP_LIST_AT(L, 1), \ |
| BOOST_PP_CAT(_, \ |
| BOOST_PP_ADD(N, \ |
| BOOST_PP_LIST_AT(L, 0) \ |
| ) \ |
| ) \ |
| ) \ |
| ) \ |
| /**/ |
| |
| #define BSL_INST_xNODES(Z, N, L) \ |
| T ## L T ## L ## _ ## N( \ |
| BOOST_PP_REPEAT_ ## Z( \ |
| BSL_NODE_MAX, BSL_INST_yNODES, \ |
| (BOOST_PP_MUL(N, BSL_NODE_MAX), (BOOST_PP_SUB(L, 1), BOOST_PP_NIL)) \ |
| ) \ |
| ); \ |
| /**/ |
| |
| #define BSL_INST_NODES(Z, N, L) \ |
| BOOST_PP_REPEAT_ ## Z( \ |
| BSL_EXP(BSL_NODE_MAX, BOOST_PP_SUB(BSL_DEPTH, N)), \ |
| BSL_INST_xNODES, N \ |
| ) \ |
| /**/ |
| |
| #define BSL_TYPEDEF_NODES(Z, N, L) \ |
| typedef boost::archive::xml::node< \ |
| BOOST_PP_ENUM_ ## Z( \ |
| BSL_NODE_MAX, BSL_PRINT, BOOST_PP_CAT(T, BOOST_PP_SUB(N, 1)) \ |
| ) \ |
| > T ## N; \ |
| /**/ |
| |
| // main macro |
| |
| #define BSL_MAIN \ |
| int main (void) { \ |
| using namespace boost::archive; \ |
| using namespace boost::archive::xml; \ |
| \ |
| typedef node<BOOST_PP_ENUM(BSL_NODE_MAX, BSL_PRINT, BSL_TYPE)> T0; \ |
| \ |
| BOOST_PP_REPEAT_FROM_TO(1, BSL_DEPTH, BSL_TYPEDEF_NODES, _) \ |
| \ |
| typedef node<BOOST_PP_ENUM( \ |
| BSL_NODE_MAX, BSL_PRINT, \ |
| BOOST_PP_CAT(T, BOOST_PP_SUB(BSL_DEPTH, 1)) \ |
| )> HEAD; \ |
| \ |
| result_set results; \ |
| std::size_t rounds = BSL_ROUNDS; \ |
| \ |
| while (rounds --> 0) { \ |
| BOOST_PP_REPEAT(BSL_EXP(BSL_NODE_MAX, BSL_DEPTH), BSL_INST_BASE, _) \ |
| \ |
| BOOST_PP_REPEAT_FROM_TO(1, BSL_DEPTH, BSL_INST_NODES, _) \ |
| \ |
| HEAD h(BOOST_PP_ENUM_PARAMS( \ |
| BSL_NODE_MAX, \ |
| BOOST_PP_CAT(T, BOOST_PP_CAT(BOOST_PP_SUB(BSL_DEPTH, 1), _)) \ |
| )); \ |
| \ |
| std::string fn = save_archive(h); \ |
| \ |
| std::pair<double, HEAD> r = restore_archive<HEAD>(fn); \ |
| \ |
| std::cout << "round " \ |
| << ((BSL_ROUNDS - 1) - rounds) \ |
| << " -> " << fn << "\n"; \ |
| \ |
| BOOST_PP_IF(BSL_SAVE_TMPFILE, \ |
| BOOST_PP_EMPTY(), \ |
| std::remove(fn.c_str()); \ |
| ) \ |
| \ |
| results.entries.push_back(entry( \ |
| BOOST_PP_STRINGIZE(BSL_TYPE), \ |
| BSL_EXP(BSL_NODE_MAX, BSL_DEPTH), r.first \ |
| )); \ |
| } \ |
| \ |
| std::fstream fs(BSL_RESULTS_FILE, std::fstream::in); \ |
| \ |
| if (fs.good()) { \ |
| xml_iarchive ia(fs); \ |
| ia >> BOOST_SERIALIZATION_NVP(results); \ |
| fs.close(); \ |
| } \ |
| \ |
| fs.open(BSL_RESULTS_FILE, std::fstream::out | std::fstream::trunc); \ |
| xml_oarchive oa(fs); \ |
| oa << BOOST_SERIALIZATION_NVP(results); \ |
| \ |
| fs.close(); \ |
| } \ |
| /**/ |
| |
| #endif // BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP |
