Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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 00000000..6f8cbf96
--- /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