prevector.cpp raw

   1  // Copyright (c) 2015-2022 The Limenka developers
   2  // Distributed under the MIT software license, see the accompanying
   3  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4  
   5  #include <prevector.h>
   6  
   7  #include <bench/bench.h>
   8  #include <script/script.h>
   9  #include <serialize.h>
  10  #include <streams.h>
  11  
  12  #include <type_traits>
  13  #include <vector>
  14  
  15  struct nontrivial_t {
  16      int x{-1};
  17      nontrivial_t() = default;
  18      SERIALIZE_METHODS(nontrivial_t, obj) { READWRITE(obj.x); }
  19  };
  20  static_assert(!std::is_trivially_default_constructible<nontrivial_t>::value,
  21                "expected nontrivial_t to not be trivially constructible");
  22  
  23  typedef unsigned char trivial_t;
  24  static_assert(std::is_trivially_default_constructible<trivial_t>::value,
  25                "expected trivial_t to be trivially constructible");
  26  
  27  template <typename T>
  28  static void PrevectorDestructor(benchmark::Bench& bench)
  29  {
  30      bench.batch(2).run([&] {
  31          prevector<CScriptBase::STATIC_SIZE, T> t0;
  32          prevector<CScriptBase::STATIC_SIZE, T> t1;
  33          t0.resize(CScriptBase::STATIC_SIZE);
  34          t1.resize(CScriptBase::STATIC_SIZE + 1);
  35      });
  36  }
  37  
  38  template <typename T>
  39  static void PrevectorClear(benchmark::Bench& bench)
  40  {
  41      prevector<CScriptBase::STATIC_SIZE, T> t0;
  42      prevector<CScriptBase::STATIC_SIZE, T> t1;
  43      bench.batch(2).run([&] {
  44          t0.resize(CScriptBase::STATIC_SIZE);
  45          t0.clear();
  46          t1.resize(CScriptBase::STATIC_SIZE + 1);
  47          t1.clear();
  48      });
  49  }
  50  
  51  template <typename T>
  52  static void PrevectorResize(benchmark::Bench& bench)
  53  {
  54      prevector<CScriptBase::STATIC_SIZE, T> t0;
  55      prevector<CScriptBase::STATIC_SIZE, T> t1;
  56      bench.batch(4).run([&] {
  57          t0.resize(CScriptBase::STATIC_SIZE);
  58          t0.resize(0);
  59          t1.resize(CScriptBase::STATIC_SIZE + 1);
  60          t1.resize(0);
  61      });
  62  }
  63  
  64  template <typename T>
  65  static void PrevectorDeserialize(benchmark::Bench& bench)
  66  {
  67      DataStream s0{};
  68      prevector<CScriptBase::STATIC_SIZE, T> t0;
  69      t0.resize(CScriptBase::STATIC_SIZE);
  70      for (auto x = 0; x < 900; ++x) {
  71          s0 << t0;
  72      }
  73      t0.resize(100);
  74      for (auto x = 0; x < 101; ++x) {
  75          s0 << t0;
  76      }
  77      bench.batch(1000).run([&] {
  78          prevector<CScriptBase::STATIC_SIZE, T> t1;
  79          for (auto x = 0; x < 1000; ++x) {
  80              s0 >> t1;
  81          }
  82          s0.Rewind();
  83      });
  84  }
  85  
  86  template <typename T>
  87  static void PrevectorFillVectorDirect(benchmark::Bench& bench)
  88  {
  89      bench.run([&] {
  90          std::vector<prevector<CScriptBase::STATIC_SIZE, T>> vec;
  91          vec.reserve(260);
  92          for (size_t i = 0; i < 260; ++i) {
  93              vec.emplace_back();
  94          }
  95      });
  96  }
  97  
  98  
  99  template <typename T>
 100  static void PrevectorFillVectorIndirect(benchmark::Bench& bench)
 101  {
 102      bench.run([&] {
 103          std::vector<prevector<CScriptBase::STATIC_SIZE, T>> vec;
 104          vec.reserve(260);
 105          for (size_t i = 0; i < 260; ++i) {
 106              // force allocation
 107              vec.emplace_back(CScriptBase::STATIC_SIZE + 1, T{});
 108          }
 109      });
 110  }
 111  
 112  #define PREVECTOR_TEST(name)                                         \
 113      static void Prevector##name##Nontrivial(benchmark::Bench& bench) \
 114      {                                                                \
 115          Prevector##name<nontrivial_t>(bench);                        \
 116      }                                                                \
 117      BENCHMARK(Prevector##name##Nontrivial, benchmark::PriorityLevel::HIGH);         \
 118      static void Prevector##name##Trivial(benchmark::Bench& bench)    \
 119      {                                                                \
 120          Prevector##name<trivial_t>(bench);                           \
 121      }                                                                \
 122      BENCHMARK(Prevector##name##Trivial, benchmark::PriorityLevel::HIGH);
 123  
 124  PREVECTOR_TEST(Clear)
 125  PREVECTOR_TEST(Destructor)
 126  PREVECTOR_TEST(Resize)
 127  PREVECTOR_TEST(Deserialize)
 128  PREVECTOR_TEST(FillVectorDirect)
 129  PREVECTOR_TEST(FillVectorIndirect)
 130