third-party/benchmark/src/benchmark_register.h

   1 #ifndef BENCHMARK_REGISTER_H
   2 #define BENCHMARK_REGISTER_H
   3
   4 #include <limits>
   5 #include <vector>
   6
   7 #include "check.h"
   8
   9 namespace benchmark {
  10 namespace internal {
  11
  12 // Append the powers of 'mult' in the closed interval [lo, hi].
  13 // Returns iterator to the start of the inserted range.
  14 template <typename T>
  15 typename std::vector<T>::iterator AddPowers(std::vector<T>* dst, T lo, T hi,
  16                                             int mult) {
  17   BM_CHECK_GE(lo, 0);
  18   BM_CHECK_GE(hi, lo);
  19   BM_CHECK_GE(mult, 2);
  20
  21   const size_t start_offset = dst->size();
  22
  23   static const T kmax = std::numeric_limits<T>::max();
  24
  25   // Space out the values in multiples of "mult"
  26   for (T i = static_cast<T>(1); i <= hi; i *= mult) {
  27     if (i >= lo) {
  28       dst->push_back(i);
  29     }
  30     // Break the loop here since multiplying by
  31     // 'mult' would move outside of the range of T
  32     if (i > kmax / mult) break;
  33   }
  34
  35   return dst->begin() + start_offset;
  36 }
  37
  38 template <typename T>
  39 void AddNegatedPowers(std::vector<T>* dst, T lo, T hi, int mult) {
  40   // We negate lo and hi so we require that they cannot be equal to 'min'.
  41   BM_CHECK_GT(lo, std::numeric_limits<T>::min());
  42   BM_CHECK_GT(hi, std::numeric_limits<T>::min());
  43   BM_CHECK_GE(hi, lo);
  44   BM_CHECK_LE(hi, 0);
  45
  46   // Add positive powers, then negate and reverse.
  47   // Casts necessary since small integers get promoted
  48   // to 'int' when negating.
  49   const auto lo_complement = static_cast<T>(-lo);
  50   const auto hi_complement = static_cast<T>(-hi);
  51
  52   const auto it = AddPowers(dst, hi_complement, lo_complement, mult);
  53
  54   std::for_each(it, dst->end(), [](T& t) { t *= -1; });
  55   std::reverse(it, dst->end());
  56 }
  57
  58 template <typename T>
  59 void AddRange(std::vector<T>* dst, T lo, T hi, int mult) {
  60   static_assert(std::is_integral<T>::value && std::is_signed<T>::value,
  61                 "Args type must be a signed integer");
  62
  63   BM_CHECK_GE(hi, lo);
  64   BM_CHECK_GE(mult, 2);
  65
  66   // Add "lo"
  67   dst->push_back(lo);
  68
  69   // Handle lo == hi as a special case, so we then know
  70   // lo < hi and so it is safe to add 1 to lo and subtract 1
  71   // from hi without falling outside of the range of T.
  72   if (lo == hi) return;
  73
  74   // Ensure that lo_inner <= hi_inner below.
  75   if (lo + 1 == hi) {
  76     dst->push_back(hi);
  77     return;
  78   }
  79
  80   // Add all powers of 'mult' in the range [lo+1, hi-1] (inclusive).
  81   const auto lo_inner = static_cast<T>(lo + 1);
  82   const auto hi_inner = static_cast<T>(hi - 1);
  83
  84   // Insert negative values
  85   if (lo_inner < 0) {
  86     AddNegatedPowers(dst, lo_inner, std::min(hi_inner, T{-1}), mult);
  87   }
  88
  89   // Treat 0 as a special case (see discussion on #762).
  90   if (lo < 0 && hi >= 0) {
  91     dst->push_back(0);
  92   }
  93
  94   // Insert positive values
  95   if (hi_inner > 0) {
  96     AddPowers(dst, std::max(lo_inner, T{1}), hi_inner, mult);
  97   }
  98
  99   // Add "hi" (if different from last value).
 100   if (hi != dst->back()) {
 101     dst->push_back(hi);
 102   }
 103 }
 104
 105 }  // namespace internal
 106 }  // namespace benchmark
 107
 108 #endif  // BENCHMARK_REGISTER_H