[Boost-commit] svn:boost r55083 - in trunk/libs/spirit/benchmarks: . qi

Subject: [Boost-commit] svn:boost r55083 - in trunk/libs/spirit/benchmarks: . qi
From: joel_at_[hidden]
Date: 2009-07-22 12:54:20

Author: djowel
Date: 2009-07-22 12:54:20 EDT (Wed, 22 Jul 2009)
New Revision: 55083
URL: http://svn.boost.org/trac/boost/changeset/55083

Log:
Updates to boilerplate benchmark code
Text files modified: 
   trunk/libs/spirit/benchmarks/boiler_plate.cpp   |    38 ++++--                                  
   trunk/libs/spirit/benchmarks/measure.hpp        |    77 ++++++++------                          
   trunk/libs/spirit/benchmarks/qi/uint_parser.cpp |   220 ++++----------------------------------- 
   3 files changed, 93 insertions(+), 242 deletions(-)

Modified: trunk/libs/spirit/benchmarks/boiler_plate.cpp
==============================================================================
--- trunk/libs/spirit/benchmarks/boiler_plate.cpp	(original)
+++ trunk/libs/spirit/benchmarks/boiler_plate.cpp	2009-07-22 12:54:20 EDT (Wed, 22 Jul 2009)
@@ -4,8 +4,11 @@
     Distributed under 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)
 ==============================================================================*/
+
+// determine the type of the live_code. we can use this to test the
+// result of the code we are benchmarking
+#define BOOST_SPIRIT_TEST_LIVE_CODE_TYPE long long
 #include "measure.hpp"
-#include <iostream>
 
 namespace
 {
@@ -13,12 +16,17 @@
     {
         typedef int type;
 
-        void operator()(int x)
+        void benchmark(int x)
         {
-            this->val ^= x; // here is where you put code that you want
+            this->val += x; // Here is where you put code that you want
                             // to benchmark. Make sure it returns something.
                             // Anything.
         }
+        
+        static int initial()
+        {
+            return 1; // our initial value
+        }
 
         int val; // this is where the value is accumulated
     };
@@ -26,17 +34,15 @@
 
 int main()
 {
-    int result;
-    double base_time;
-    int ret = test::run<f>(result, base_time, 100);
-
-    std::cout
-        << "f accumulated result:           "
-        << result
-        << std::endl
-        << "f time:                         "
-        << base_time
-        << std::endl;
-
-    return ret;
+    BOOST_SPIRIT_TEST_BENCHMARK(
+        1000000,    // This is the maximum repetitions to execute
+        (f)         // Place your tests here. For now, we have only one test: (f)
+                    // If you have 3 tests a, b and c, this line will contain (a)(b)(c)
+    )
+    
+    // This is ultimately responsible for preventing all the test code
+    // from being optimized away.  Change this to return 0 and you
+    // unplug the whole test's life support system.
+    return test::live_code != 0;
 }
+

Modified: trunk/libs/spirit/benchmarks/measure.hpp
==============================================================================
--- trunk/libs/spirit/benchmarks/measure.hpp	(original)
+++ trunk/libs/spirit/benchmarks/measure.hpp	2009-07-22 12:54:20 EDT (Wed, 22 Jul 2009)
@@ -2,6 +2,8 @@
 // 2005. Distributed under 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_SPIRIT_TEST_BENCHMARK_HPP)
+#define BOOST_SPIRIT_TEST_BENCHMARK_HPP
 
 #ifdef _MSC_VER
 // inline aggressively
@@ -10,11 +12,14 @@
 # define _SECURE_SCL 0 
 #endif
 
-#if !defined(LIVE_CODE_TYPE)
-# define LIVE_CODE_TYPE int
+#if !defined(BOOST_SPIRIT_TEST_LIVE_CODE_TYPE)
+# define BOOST_SPIRIT_TEST_LIVE_CODE_TYPE int
 #endif
 
 #include "high_resolution_timer.hpp"
+#include <iostream>
+#include  <boost/preprocessor/seq/for_each.hpp>
+#include  <boost/preprocessor/stringize.hpp>
 
 namespace test
 {
@@ -22,12 +27,12 @@
     // code elimination doesn't optimize away anything we're testing.
     // We'll use it to compute the return code of the executable to make
     // sure it's needed.
-    LIVE_CODE_TYPE live_code;
+    BOOST_SPIRIT_TEST_LIVE_CODE_TYPE live_code;
 
     // Call objects of the given Accumulator type repeatedly with x as
     // an argument.
-    template <class Accumulator, class Arg>
-    void hammer(Arg const& x, long const repeats)
+    template <class Accumulator>
+    void hammer(long const repeats)
     {
         // Strategy: because the sum in an accumulator after each call
         // depends on the previous value of the sum, the CPU's pipeline
@@ -50,6 +55,8 @@
         // or L3 cache, or main memory, you can increase the size of
         // this array.  1024 is an upper limit on the pipeline depth of
         // current vector machines.
+        
+        typename Accumulator::type x = Accumulator::initial();
         const std::size_t number_of_accumulators = 1024;
         live_code = 0; // reset to zero
 
@@ -59,7 +66,7 @@
         {
             for (Accumulator* ap = a;  ap < a + number_of_accumulators; ++ap)
             {
-                (*ap)(x);
+                ap->benchmark(x);
             }
         }
 
@@ -73,42 +80,46 @@
 
     // Measure the time required to hammer accumulators of the given
     // type with the argument x.
-    template <class Accumulator, class T>
-    double measure(T const& x, long const repeats)
+    template <class Accumulator>
+    double measure(long const repeats)
     {
         // Hammer accumulators a couple of times to ensure the
         // instruction cache is full of our test code, and that we don't
         // measure the cost of a page fault for accessing the data page
         // containing the memory where the accumulators will be
         // allocated
-        hammer<Accumulator>(x, repeats);
-        hammer<Accumulator>(x, repeats);
+        hammer<Accumulator>(repeats);
+        hammer<Accumulator>(repeats);
 
         // Now start a timer
         util::high_resolution_timer time;
-        hammer<Accumulator>(x, repeats);  // This time, we'll measure
+        hammer<Accumulator>(repeats);  // This time, we'll measure
         return time.elapsed() / repeats;  // return the time of one iteration
     }
-  
-    template <typename Accumulator>
-    static int run(typename Accumulator::type& result, double& base_time, long repeats = 100)
-    {
-        double measured = 0;
-        while (measured < 2.0 && repeats <= 10000000)
-        {
-            repeats *= 10;
-            util::high_resolution_timer time;
-            test::hammer<Accumulator>(0, repeats);
-            measured = time.elapsed();
-        }
-
-        test::measure<Accumulator>(1, 1);
-        result = test::live_code;
-        base_time = test::measure<Accumulator>(1, repeats);
-
-        // This is ultimately responsible for preventing all the test code
-        // from being optimized away.  Change this to return 0 and you
-        // unplug the whole test's life support system.
-        return test::live_code != 0;
-    }
+    
+#define BOOST_SPIRIT_TEST_HAMMER(r, data, elem)                     \
+    test::hammer<elem>(repeats);
+    /***/
+
+#define BOOST_SPIRIT_TEST_MEASURE(r, data, elem)                    \
+    std::cout                                                       \
+        << BOOST_PP_STRINGIZE(elem) << ": "                         \
+        << test::measure<elem>(repeats)                             \
+        << std::endl;
+    /***/
+
+#define BOOST_SPIRIT_TEST_BENCHMARK(max_repeats, FSeq)              \
+    long repeats = 100;                                             \
+    double measured = 0;                                            \
+    while (measured < 2.0 && repeats <= max_repeats)                \
+    {                                                               \
+        repeats *= 10;                                              \
+        util::high_resolution_timer time;                           \
+        BOOST_PP_SEQ_FOR_EACH(BOOST_SPIRIT_TEST_HAMMER, _, FSeq)    \
+        measured = time.elapsed();                                  \
+    }                                                               \
+    BOOST_PP_SEQ_FOR_EACH(BOOST_SPIRIT_TEST_MEASURE, _, FSeq)       \
+    /***/
 }
+
+#endif
\ No newline at end of file

Modified: trunk/libs/spirit/benchmarks/qi/uint_parser.cpp
==============================================================================
--- trunk/libs/spirit/benchmarks/qi/uint_parser.cpp	(original)
+++ trunk/libs/spirit/benchmarks/qi/uint_parser.cpp	2009-07-22 12:54:20 EDT (Wed, 22 Jul 2009)
@@ -3,206 +3,40 @@
 
     Distributed under 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_MSVC)
-#pragma inline_depth(255)
-#pragma inline_recursion(on)
-#define _SECURE_SCL 0 
-#endif // defined(BOOST_MSVC)
-
-#include "../high_resolution_timer.hpp"
-#include <boost/spirit/include/qi.hpp>
-#include <boost/lexical_cast.hpp>
-#include <climits>
-#include <cstdlib>
-#include <string>
-#include <vector>
-#include <sstream>
+==============================================================================*/
+#include "measure.hpp"
+#include <iostream>
 
-#define MAX_ITERATION 1000000
-
-void check(int a, int b)
+namespace
 {
-    if (a != b)
-    {
-        std::cout << "Parse Error, got: " << a << " and " << b << std::endl;
-        abort();
-    }
-}
-
-int main()
-{
-    namespace qi = boost::spirit::qi;
-    using qi::int_;
-    
-    std::cout << "initializing input strings..." << std::endl;
-    std::vector<int> src(MAX_ITERATION);
-    std::vector<std::string> src_str(MAX_ITERATION);
-    for (int i = 0; i < MAX_ITERATION; ++i)
-    {
-        src[i] = std::rand() * std::rand();
-        if (std::rand() % 2)
-            src[i] = -src[i];
-        src_str[i] = boost::lexical_cast<std::string>(src[i]);
-    }
-    
-    // test the C libraries atoi function (the most low level function for
-    // string conversion available)
-    {
-        std::vector<int> v(MAX_ITERATION);
-        std::vector<char const*> f(MAX_ITERATION);
-
-        // get the C string
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            f[i] = src_str[i].c_str();
-        }
-        
-        util::high_resolution_timer t;
-
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            v[i] = atoi(f[i]);
-        }
-
-        std::cout << "atoi: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
-    
-    // test the C libraries strtol function (the most low level function for
-    // string conversion available)
-    {
-        std::vector<int> v(MAX_ITERATION);
-        std::vector<char const*> f(MAX_ITERATION);
-
-        // get the C string
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            f[i] = src_str[i].c_str();
-        }
-
-        util::high_resolution_timer t;
-
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            v[i] = strtol(f[i], 0, 10);
-        }
-
-        std::cout << "strtol: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
-    
-    // test sscanf
-    {
-        std::vector<int> v(MAX_ITERATION);
-        std::vector<char const*> f(MAX_ITERATION);
-
-        // get the C string
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            f[i] = src_str[i].c_str();
-        }
-
-        util::high_resolution_timer t;
-
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            sscanf(f[i], "%d", &v[i]);
-        }
-
-        std::cout << "sscanf: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
-
-    // test iostream
+    struct f
     {
-        std::istringstream ss;
-        std::vector<int> v(MAX_ITERATION);
-        util::high_resolution_timer t;
+        typedef int type;
 
-        for (int i = 0; i < MAX_ITERATION; ++i)
+        void operator()(int x)
         {
-            ss.clear();
-            ss.str(src_str[i]);
-            ss >> v[i];
+            this->val ^= x; // here is where you put code that you want
+                            // to benchmark. Make sure it returns something.
+                            // Anything.
         }
 
-        std::cout << "std::iostream: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
-    
-    // test boost::lexical_cast
-    {
-        std::vector<int> v(MAX_ITERATION);
-        std::vector<char const*> f(MAX_ITERATION);
-
-        // get the C string
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            f[i] = src_str[i].c_str();
-        }
-
-        util::high_resolution_timer t;
-
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            v[i] = boost::lexical_cast<int>(src[i]);
-        }
-
-        std::cout << "boost::lexical_cast: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
-    
-    // test the Qi int_ parser routines 
-    {
-        std::vector<int> v(MAX_ITERATION);
-        std::vector<char const*> f(MAX_ITERATION);
-        std::vector<char const*> l(MAX_ITERATION);
-
-        // get the first/last iterators
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            f[i] = src_str[i].c_str();
-            l[i] = f[i];
-            while (*l[i])
-                l[i]++;
-        }
-    
-        util::high_resolution_timer t;
-
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            qi::parse(f[i], l[i], int_, v[i]);
-        }
+        int val; // this is where the value is accumulated
+    };
+}
 
-        std::cout << "spirit int_: " << t.elapsed() << " [s]" << std::flush << std::endl;
-        
-        for (int i = 0; i < MAX_ITERATION; ++i)
-        {
-            check(v[i], src[i]);
-        }
-    }
+int main()
+{
+    int result;
+    double base_time;
+    int ret = test::run<f>(result, base_time, 100);
+
+    std::cout
+        << "f accumulated result:           "
+        << result
+        << std::endl
+        << "f time:                         "
+        << base_time
+        << std::endl;
 
-    return 0;
+    return ret;
 }
-