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 25 inline std::default_random_engine& getRandomEngine() { 26 static std::default_random_engine RandEngine(std::random_device{}()); 27 return RandEngine; 28 } 29 30 inline char getRandomChar() { 31 std::uniform_int_distribution<> LettersDist(0, LettersSize - 1); 32 return Letters[LettersDist(getRandomEngine())]; 33 } 34 35 template <class IntT> 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 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> 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> 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> 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> 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> 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> 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> 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 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 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 124 inline std::vector<std::string> getRandomStringInputs(std::size_t N) { 125 return getRandomStringInputsWithLength(N, 1024); 126 } 127 128 template <class IntT> 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 137 inline std::vector<std::string> getSSORandomStringInputs(size_t N) { 138 std::vector<std::string> inputs; 139 for (size_t i = 0; i < N; ++i) 140 inputs.push_back(getRandomString(10)); // SSO 141 return inputs; 142 } 143 144 inline std::vector<std::string> getPrefixedRandomStringInputs(size_t N) { 145 std::vector<std::string> inputs; 146 inputs.reserve(N); 147 constexpr int kSuffixLength = 32; 148 const std::string prefix = getRandomString(1024 - kSuffixLength); 149 for (std::size_t i = 0; i < N; ++i) 150 inputs.push_back(prefix + getRandomString(kSuffixLength)); 151 return inputs; 152 } 153 154 inline std::vector<std::string> getSortedStringInputs(std::size_t N) { 155 std::vector<std::string> inputs = getRandomStringInputs(N); 156 std::sort(inputs.begin(), inputs.end()); 157 return inputs; 158 } 159 160 inline std::vector<std::string> getReverseSortedStringInputs(std::size_t N) { 161 std::vector<std::string> inputs = getSortedStringInputs(N); 162 std::reverse(inputs.begin(), inputs.end()); 163 return inputs; 164 } 165 166 inline std::vector<const char*> getRandomCStringInputs(std::size_t N) { 167 static std::vector<std::string> inputs = getRandomStringInputs(N); 168 std::vector<const char*> cinputs; 169 for (auto const& str : inputs) 170 cinputs.push_back(str.c_str()); 171 return cinputs; 172 } 173 174 #endif // BENCHMARK_GENERATE_INPUT_H 175