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