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