diff options
Diffstat (limited to 'src/boost/libs/serialization/performance/xml/macro.hpp')
| -rw-r--r-- | src/boost/libs/serialization/performance/xml/macro.hpp | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/src/boost/libs/serialization/performance/xml/macro.hpp b/src/boost/libs/serialization/performance/xml/macro.hpp new file mode 100644 index 000000000..6f8cbf963 --- /dev/null +++ b/src/boost/libs/serialization/performance/xml/macro.hpp @@ -0,0 +1,229 @@ +/* /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) + #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 |