Unify common bench types into the bench_utils.hpp header

Author: igaztanaga

bench/bench_adaptive_node_pool.cpp

@@ -30,8 +30,8 @@
 #include <cassert>   //assert
 
 #include <boost/move/detail/nsec_clock.hpp>
+#include "bench_utils.hpp"   //MyInt
 
-using boost::move_detail::cpu_timer;
 using boost::move_detail::cpu_times;
 using boost::move_detail::nanosecond_type;
 
@@ -115,22 +115,6 @@ template<> struct get_allocator_name<SimpleSegregatedStorageV1>
 template<> struct get_allocator_name<SimpleSegregatedStorageV2>
 {  static const char *get() {  return "SimpleSegregatedStorageV2";  } };
 
-class MyInt
-{
-   std::size_t int_;
-
-   public:
-   explicit MyInt(std::size_t i = 0) : int_(i){}
-   MyInt(const MyInt &other)
-      :  int_(other.int_)
-   {}
-   MyInt & operator=(const MyInt &other)
-   {
-      int_ = other.int_;
-      return *this;
-   }
-};
-
 template<class Allocator>
 void list_test_template(std::size_t num_iterations, std::size_t num_elements, bool csv_output)
 {
@@ -143,11 +127,11 @@ void list_test_template(std::size_t num_iterations, std::size_t num_elements, bo
    typedef bc::list<MyInt, IntAllocator>  list_t;
    typedef typename list_t::iterator      iterator_t;
    {
-      cpu_timer timer;
+      boost::move_detail::cpu_timer timer;
       timer.resume();
       list_t l;
       for(std::size_t r = 0; r != num_iterations; ++r){
-         l.insert(l.end(), num_elements, MyInt(r));
+         l.insert(l.end(), num_elements, MyInt((int)r));
       }
       timer.stop();
       tinsert = timer.elapsed().wall;

bench/bench_alloc_expand_bwd.cpp

@@ -23,36 +23,11 @@
 
 #include <boost/move/detail/nsec_clock.hpp>
 
-using boost::move_detail::cpu_timer;
+#include "bench_utils.hpp"   //MyInt
+
 using boost::move_detail::cpu_times;
 using boost::move_detail::nanosecond_type;
 
-//typedef int MyInt;
-
-class MyInt
-{
-   int int_;
-
-   public:
-   MyInt(int i = 0)
-      : int_(i)
-   {}
-
-   MyInt(const MyInt &other)
-      :  int_(other.int_)
-   {}
-
-   MyInt & operator=(const MyInt &other)
-   {
-      int_ = other.int_;
-      return *this;
-   }
-
-   ~MyInt()
-   {
-      int_ = 0;
-   }
-};
 namespace boost{
 
 template<class T>
@@ -105,7 +80,7 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
    typedef Allocator IntAllocator;
    std::size_t numalloc = 0, numexpand = 0;
 
-   cpu_timer timer;
+   boost::move_detail::cpu_timer timer;
    timer.resume();
 
    std::size_t capacity = 0;

bench/bench_alloc_expand_fwd.cpp

@@ -25,7 +25,7 @@
 #include <cstring>   //std::strcmp
 #include <boost/move/detail/nsec_clock.hpp>
 #include <typeinfo>
-using boost::move_detail::cpu_timer;
+#include "bench_utils.hpp"   //MyInt
 using boost::move_detail::cpu_times;
 using boost::move_detail::nanosecond_type;
 
@@ -59,37 +59,12 @@ static std::size_t get_num_expand(bc::vector<T, Allocator> &v)
 
 #endif   //BOOST_CONTAINER_VECTOR_ALLOC_STATS
 
-class MyInt
-{
-   int int_;
-
-   public:
-   explicit MyInt(int i = 0)
-      : int_(i)
-   {}
-
-   MyInt(const MyInt &other)
-      :  int_(other.int_)
-   {}
-
-   MyInt & operator=(const MyInt &other)
-   {
-      int_ = other.int_;
-      return *this;
-   }
-
-   ~MyInt()
-   {
-      int_ = 0;
-   }
-};
-
 template<class Container>
 void vector_test_template(std::size_t num_iterations, std::size_t num_elements)
 {
    std::size_t numalloc = 0, numexpand = 0;
 
-   cpu_timer timer;
+   boost::move_detail::cpu_timer timer;
    timer.resume();
 
    std::size_t capacity = 0;

bench/bench_alloc_shrink_to_fit.cpp

@@ -25,30 +25,12 @@
 #include <cassert>   //assert
 
 #include <boost/move/detail/nsec_clock.hpp>
-using boost::move_detail::cpu_timer;
+#include "bench_utils.hpp"   //MyInt
 using boost::move_detail::cpu_times;
 using boost::move_detail::nanosecond_type;
 
 namespace bc = boost::container;
 
-class MyInt
-{
-   std::ptrdiff_t int_; //Use a type that will grow on 64 bit machines
-
-   public:
-   MyInt(int i = 0) : int_(i){}
-
-   MyInt(const MyInt &other)
-      :  int_(other.int_)
-   {}
-
-   MyInt & operator=(const MyInt &other)
-   {
-      int_ = other.int_;
-      return *this;
-   }
-};
-
 typedef std::allocator<MyInt>   StdAllocator;
 typedef bc::allocator<MyInt, 2> AllocatorPlusV2;
 typedef bc::allocator<MyInt, 1> AllocatorPlusV1;
@@ -76,11 +58,17 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
    typedef Allocator IntAllocator;
 
    std::size_t capacity = 0;
-   const std::size_t Step = 5;
+   //Erase enough elements per iteration to free ~40 bytes (as the original
+   //8-byte element x Step 5 did). A version-2 allocator can only shrink in
+   //place once the freed region reaches dlmalloc's chunk granularity (16 bytes
+   //on 64-bit); a smaller step (e.g. a 4-byte element x 5 = 20 bytes) fails to
+   //cross a chunk boundary every iteration, so v.num_shrink would not advance
+   //and the assertion below would fire. Step is kept a divisor of num_elements.
+   const std::size_t Step = 40u/sizeof(MyInt) ? 40u/sizeof(MyInt) : 1u;
    std::size_t num_shrink = 0;
    (void)capacity;
 
-   cpu_timer timer;
+   boost::move_detail::cpu_timer timer;
    timer.resume();
 
    #ifndef NDEBUG

bench/bench_alloc_stable_vector_burst.cpp

@@ -27,29 +27,13 @@
 #include <boost/container/stable_vector.hpp>
 #include <boost/container/vector.hpp>
 #include <boost/move/detail/nsec_clock.hpp>
+#include "bench_utils.hpp"   //MyInt
 
-using boost::move_detail::cpu_timer;
 using boost::move_detail::cpu_times;
 using boost::move_detail::nanosecond_type;
 
 namespace bc = boost::container;
 
-class MyInt
-{
-   int int_;
-
-   public:
-   MyInt(int i = 0) : int_(i){}
-   MyInt(const MyInt &other)
-      :  int_(other.int_)
-   {}
-   MyInt & operator=(const MyInt &other)
-   {
-      int_ = other.int_;
-      return *this;
-   }
-};
-
 typedef std::allocator<MyInt>   StdAllocator;
 typedef bc::allocator<MyInt, 1> AllocatorPlusV1;
 typedef bc::allocator<MyInt, 2> AllocatorPlusV2;
@@ -104,7 +88,7 @@ void stable_vector_test_template(std::size_t num_iterations, std::size_t num_ele
    {
       {
          vector_type l;
-         cpu_timer timer;
+         boost::move_detail::cpu_timer timer;
          timer.resume();
 
          for(std::size_t r = 0; r != num_iterations; ++r){

bench/bench_small_vector.cpp

@@ -13,6 +13,10 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
+#ifndef LONG_BENCH
+//#define LONG_BENCH
+#endif
+
 #include <vector>
 #include <memory>    //std::allocator
 #include <boost/container/vector.hpp>

bench/bench_static_vector.cpp

@@ -13,6 +13,10 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
+#ifndef LONG_BENCH
+//#define LONG_BENCH
+#endif
+
 #include <vector>
 #include <memory>    //std::allocator
 #include <boost/container/vector.hpp>

bench/bench_utils.hpp

@@ -12,7 +12,11 @@
 #define BOOST_CONTAINER_BENCH_UTILS_HPP
 
 #include <boost/move/detail/nsec_clock.hpp>
+#include <boost/move/utility_core.hpp>
 #include <boost/container/detail/workaround.hpp>
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
 #include <vector>
 
 volatile int bench_utils_sink = 0;
@@ -124,4 +128,110 @@ typedef boost::move_detail::cpu_timer cpu_timer;
 BOOST_CONTAINER_FORCEINLINE void clobber()       { BOOST_CONTAINER_BENCH_CLOBBER(); }
 BOOST_CONTAINER_FORCEINLINE void escape(void* p) { BOOST_CONTAINER_BENCH_ESCAPE(p); }
 
+///////////////////////////////////////////////////////////////////////////////
+// Shared benchmark element types.
+//
+// MyInt: a non-trivial "int wrapper" used by several benchmarks to exercise the
+// non-trivially-copyable element code paths (its user-provided copy ctor, copy
+// assignment and destructor disable the trivial memcpy/relocation fast paths),
+// as opposed to a plain int. This single definition replaces the per-benchmark
+// copies that used to define their own MyInt. A benchmark that additionally
+// wants the "trivial destructor after move" optimization can still specialize
+// boost::has_trivial_destructor_after_move<MyInt> in its own translation unit.
+///////////////////////////////////////////////////////////////////////////////
+class MyInt
+{
+   int int_;
+
+   public:
+   MyInt(int i = 0)
+      : int_(i)
+   {}
+
+   MyInt(const MyInt &other)
+      : int_(other.int_)
+   {}
+
+   MyInt & operator=(const MyInt &other)
+   {
+      int_ = other.int_;
+      return *this;
+   }
+
+   ~MyInt()
+   {
+      int_ = 0;
+   }
+
+   int int_value() const { return int_; }
+
+   friend bool operator==(const MyInt& a, const MyInt& b) { return a.int_ == b.int_; }
+   friend bool operator!=(const MyInt& a, const MyInt& b) { return a.int_ != b.int_; }
+   friend bool operator< (const MyInt& a, const MyInt& b) { return a.int_ <  b.int_; }
+   friend bool operator> (const MyInt& a, const MyInt& b) { return a.int_ >  b.int_; }
+   friend bool operator<=(const MyInt& a, const MyInt& b) { return a.int_ <= b.int_; }
+   friend bool operator>=(const MyInt& a, const MyInt& b) { return a.int_ >= b.int_; }
+};
+
+//Benchmark element. The NonTrivial boolean (chosen by the caller, true by
+//default) selects between two layouts of identical size:
+// - NonTrivial == true: a move-only element whose user-defined special members
+//   do measurable work (memset/memcpy of the payload, kept alive by a compiler
+//   barrier). It uses Boost.Move so the definition is also valid in C++03.
+// - NonTrivial == false: a trivially copyable element carrying only the payload.
+template<std::size_t Size, bool NonTrivial = true>
+struct element_t;
+
+template<std::size_t Size>
+struct element_t<Size, true>
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(element_t)
+
+   public:
+   element_t(int n_) : n(n_)
+   {
+      std::memset(payload, 0, sizeof(payload));
+      clobber();  //The barrier keeps previous writes as real work.
+   }
+
+   ~element_t()
+   {
+      std::memset(payload, 0, sizeof(payload));
+      clobber();  //The barrier keeps previous writes as real work.
+   }
+
+   element_t(BOOST_RV_REF(element_t) x) : n(x.n)
+   {
+      std::memcpy(payload, x.payload, sizeof(payload));
+      std::memset(x.payload, 0, sizeof(payload));
+      clobber();  //The barrier keeps previous writes as real work.
+   }
+
+   element_t& operator=(BOOST_RV_REF(element_t) x)
+   {
+      n = x.n;
+      std::memcpy(payload, x.payload, sizeof(payload));
+      std::memset(x.payload, 0, sizeof(payload));
+      clobber();  //The barrier keeps previous writes as real work.
+      return *this;
+   }
+
+   operator int() const { return n; }
+
+   int n;
+   char payload[Size - sizeof(int)];
+};
+
+template<std::size_t Size>
+struct element_t<Size, false>
+{
+   element_t(int n_) : n(n_)
+   {}
+
+   operator int() const { return n; }
+
+   int n;
+   char payload[Size - sizeof(int)];
+};
+
 #endif   //BOOST_CONTAINER_BENCH_UTILS_HPP

bench/bench_vector.cpp

@@ -35,5 +35,6 @@ void run_containers(runner<IntType, Operation>& r)
 int main()
 {
    test_vectors<int>();
+   test_vectors<MyInt>();
    return 0;
 }