benchmarks/GenerateInput.hpp

   1 #ifndef BENCHMARK_GENERATE_INPUT_HPP
   2 #define BENCHMARK_GENERATE_INPUT_HPP
   3
   4 #include <algorithm>
   5 #include <random>
   6 #include <vector>
   7 #include <string>
   8 #include <climits>
   9 #include <cstddef>
  10
  11 static const char Letters[] = {
  12     '0','1','2','3','4',
  13     '5','6','7','8','9',
  14     'A','B','C','D','E','F',
  15     'G','H','I','J','K',
  16     'L','M','N','O','P',
  17     'Q','R','S','T','U',
  18     'V','W','X','Y','Z',
  19     'a','b','c','d','e','f',
  20     'g','h','i','j','k',
  21     'l','m','n','o','p',
  22     'q','r','s','t','u',
  23     'v','w','x','y','z'
  24 };
  25 static const std::size_t LettersSize = sizeof(Letters);
  26
  27 inline std::default_random_engine& getRandomEngine() {
  28     static std::default_random_engine RandEngine(std::random_device{}());
  29     return RandEngine;
  30 }
  31
  32 inline char getRandomChar() {
  33     std::uniform_int_distribution<> LettersDist(0, LettersSize-1);
  34     return Letters[LettersDist(getRandomEngine())];
  35 }
  36
  37 template <class IntT>
  38 inline IntT getRandomInteger() {
  39     std::uniform_int_distribution<IntT> dist;
  40     return dist(getRandomEngine());
  41 }
  42
  43 inline std::string getRandomString(std::size_t Len) {
  44     std::string str(Len, 0);
  45     std::generate_n(str.begin(), Len, &getRandomChar);
  46     return str;
  47 }
  48
  49 template <class IntT>
  50 inline std::vector<IntT> getDuplicateIntegerInputs(size_t N) {
  51     std::vector<IntT> inputs(N, static_cast<IntT>(-1));
  52     return inputs;
  53 }
  54
  55 template <class IntT>
  56 inline std::vector<IntT> getSortedIntegerInputs(size_t N) {
  57     std::vector<IntT> inputs;
  58     for (size_t i=0; i < N; i += 1)
  59         inputs.push_back(i);
  60     return inputs;
  61 }
  62
  63 template <class IntT>
  64 std::vector<IntT> getSortedLargeIntegerInputs(size_t N) {
  65     std::vector<IntT> inputs;
  66     for (size_t i=0; i < N; ++i) {
  67         inputs.push_back(i + N);
  68     }
  69     return inputs;
  70 }
  71
  72 template <class IntT>
  73 std::vector<IntT> getSortedTopBitsIntegerInputs(size_t N) {
  74     std::vector<IntT> inputs = getSortedIntegerInputs<IntT>(N);
  75     for (auto& E : inputs) E <<= ((sizeof(IntT) / 2) * CHAR_BIT);
  76     return inputs;
  77 }
  78
  79 template <class IntT>
  80 inline std::vector<IntT> getReverseSortedIntegerInputs(size_t N) {
  81     std::vector<IntT> inputs;
  82     std::size_t i = N;
  83     while (i > 0) {
  84         --i;
  85         inputs.push_back(i);
  86     }
  87     return inputs;
  88 }
  89
  90 template <class IntT>
  91 std::vector<IntT> getPipeOrganIntegerInputs(size_t N) {
  92     std::vector<IntT> v; v.reserve(N);
  93     for (size_t i = 0; i < N/2; ++i) v.push_back(i);
  94     for (size_t i = N/2; i < N; ++i) v.push_back(N - i);
  95     return v;
  96 }
  97
  98
  99 template <class IntT>
 100 std::vector<IntT> getRandomIntegerInputs(size_t N) {
 101     std::vector<IntT> inputs;
 102     for (size_t i=0; i < N; ++i) {
 103         inputs.push_back(getRandomInteger<IntT>());
 104     }
 105     return inputs;
 106 }
 107
 108 inline std::vector<std::string> getDuplicateStringInputs(size_t N) {
 109     std::vector<std::string> inputs(N, getRandomString(1024));
 110     return inputs;
 111 }
 112
 113 inline std::vector<std::string> getRandomStringInputs(size_t N) {
 114     std::vector<std::string> inputs;
 115     for (size_t i=0; i < N; ++i) {
 116         inputs.push_back(getRandomString(1024));
 117     }
 118     return inputs;
 119 }
 120
 121 inline std::vector<std::string> getSortedStringInputs(size_t N) {
 122     std::vector<std::string> inputs = getRandomStringInputs(N);
 123     std::sort(inputs.begin(), inputs.end());
 124     return inputs;
 125 }
 126
 127 inline std::vector<std::string> getReverseSortedStringInputs(size_t N) {
 128     std::vector<std::string> inputs = getSortedStringInputs(N);
 129     std::reverse(inputs.begin(), inputs.end());
 130     return inputs;
 131 }
 132
 133 inline std::vector<const char*> getRandomCStringInputs(size_t N) {
 134     static std::vector<std::string> inputs = getRandomStringInputs(N);
 135     std::vector<const char*> cinputs;
 136     for (auto const& str : inputs)
 137         cinputs.push_back(str.c_str());
 138     return cinputs;
 139 }
 140
 141
 142 #endif // BENCHMARK_GENERATE_INPUT_HPP