1 #ifndef BENCHMARK_GENERATE_INPUT_H
2 #define BENCHMARK_GENERATE_INPUT_H
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
getRandomEngine()27 inline std::default_random_engine& getRandomEngine() {
28 static std::default_random_engine RandEngine(std::random_device{}());
29 return RandEngine;
30 }
31
32
getRandomChar()33 inline char getRandomChar() {
34 std::uniform_int_distribution<> LettersDist(0, LettersSize-1);
35 return Letters[LettersDist(getRandomEngine())];
36 }
37
38 template <class IntT>
getRandomInteger(IntT Min,IntT Max)39 inline IntT getRandomInteger(IntT Min, IntT Max) {
40 std::uniform_int_distribution<unsigned long long> dist(Min, Max);
41 return static_cast<IntT>(dist(getRandomEngine()));
42 }
43
getRandomString(std::size_t Len)44 inline std::string getRandomString(std::size_t Len) {
45 std::string str(Len, 0);
46 std::generate_n(str.begin(), Len, &getRandomChar);
47 return str;
48 }
49
50 template <class IntT>
getDuplicateIntegerInputs(size_t N)51 inline std::vector<IntT> getDuplicateIntegerInputs(size_t N) {
52 std::vector<IntT> inputs(N, static_cast<IntT>(-1));
53 return inputs;
54 }
55
56 template <class IntT>
getSortedIntegerInputs(size_t N)57 inline std::vector<IntT> getSortedIntegerInputs(size_t N) {
58 std::vector<IntT> inputs;
59 for (size_t i=0; i < N; i += 1)
60 inputs.push_back(i);
61 return inputs;
62 }
63
64 template <class IntT>
getSortedLargeIntegerInputs(size_t N)65 std::vector<IntT> getSortedLargeIntegerInputs(size_t N) {
66 std::vector<IntT> inputs;
67 for (size_t i=0; i < N; ++i) {
68 inputs.push_back(i + N);
69 }
70 return inputs;
71 }
72
73 template <class IntT>
getSortedTopBitsIntegerInputs(size_t N)74 std::vector<IntT> getSortedTopBitsIntegerInputs(size_t N) {
75 std::vector<IntT> inputs = getSortedIntegerInputs<IntT>(N);
76 for (auto& E : inputs) E <<= ((sizeof(IntT) / 2) * CHAR_BIT);
77 return inputs;
78 }
79
80 template <class IntT>
getReverseSortedIntegerInputs(size_t N)81 inline std::vector<IntT> getReverseSortedIntegerInputs(size_t N) {
82 std::vector<IntT> inputs;
83 std::size_t i = N;
84 while (i > 0) {
85 --i;
86 inputs.push_back(i);
87 }
88 return inputs;
89 }
90
91 template <class IntT>
getPipeOrganIntegerInputs(size_t N)92 std::vector<IntT> getPipeOrganIntegerInputs(size_t N) {
93 std::vector<IntT> v; v.reserve(N);
94 for (size_t i = 0; i < N/2; ++i) v.push_back(i);
95 for (size_t i = N/2; i < N; ++i) v.push_back(N - i);
96 return v;
97 }
98
99
100 template <class IntT>
getRandomIntegerInputs(size_t N)101 std::vector<IntT> getRandomIntegerInputs(size_t N) {
102 std::vector<IntT> inputs;
103 for (size_t i=0; i < N; ++i) {
104 inputs.push_back(getRandomInteger<IntT>(0, std::numeric_limits<IntT>::max()));
105 }
106 return inputs;
107 }
108
getDuplicateStringInputs(size_t N)109 inline std::vector<std::string> getDuplicateStringInputs(size_t N) {
110 std::vector<std::string> inputs(N, getRandomString(1024));
111 return inputs;
112 }
113
getRandomStringInputs(size_t N)114 inline std::vector<std::string> getRandomStringInputs(size_t N) {
115 std::vector<std::string> inputs;
116 for (size_t i=0; i < N; ++i) {
117 inputs.push_back(getRandomString(1024));
118 }
119 return inputs;
120 }
121
getSortedStringInputs(size_t N)122 inline std::vector<std::string> getSortedStringInputs(size_t N) {
123 std::vector<std::string> inputs = getRandomStringInputs(N);
124 std::sort(inputs.begin(), inputs.end());
125 return inputs;
126 }
127
getReverseSortedStringInputs(size_t N)128 inline std::vector<std::string> getReverseSortedStringInputs(size_t N) {
129 std::vector<std::string> inputs = getSortedStringInputs(N);
130 std::reverse(inputs.begin(), inputs.end());
131 return inputs;
132 }
133
getRandomCStringInputs(size_t N)134 inline std::vector<const char*> getRandomCStringInputs(size_t N) {
135 static std::vector<std::string> inputs = getRandomStringInputs(N);
136 std::vector<const char*> cinputs;
137 for (auto const& str : inputs)
138 cinputs.push_back(str.c_str());
139 return cinputs;
140 }
141
142
143 #endif // BENCHMARK_GENERATE_INPUT_H
144