Eric Fiselier | fd2e3e9 | 2018-01-18 04:23:01 +0000 | [diff] [blame] | 1 | #include "benchmark/benchmark.h" |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 2 | #include "GenerateInput.hpp" |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 3 | #include "test_iterators.h" |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 4 | #include "filesystem_include.hpp" |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 5 | |
| 6 | static const size_t TestNumInputs = 1024; |
| 7 | |
| 8 | |
| 9 | template <class GenInputs> |
| 10 | void BM_PathConstructString(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 11 | using fs::path; |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 12 | const auto in = gen(st.range(0)); |
| 13 | path PP; |
| 14 | for (auto& Part : in) |
| 15 | PP /= Part; |
| 16 | benchmark::DoNotOptimize(PP.native().data()); |
| 17 | while (st.KeepRunning()) { |
| 18 | const path P(PP.native()); |
| 19 | benchmark::DoNotOptimize(P.native().data()); |
| 20 | } |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 21 | st.SetComplexityN(st.range(0)); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 22 | } |
Eric Fiselier | ad1a12c | 2016-10-30 23:53:50 +0000 | [diff] [blame] | 23 | BENCHMARK_CAPTURE(BM_PathConstructString, large_string, |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 24 | getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 25 | |
| 26 | |
| 27 | template <class GenInputs> |
Eric Fiselier | ad1a12c | 2016-10-30 23:53:50 +0000 | [diff] [blame] | 28 | void BM_PathConstructCStr(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 29 | using fs::path; |
Eric Fiselier | ad1a12c | 2016-10-30 23:53:50 +0000 | [diff] [blame] | 30 | const auto in = gen(st.range(0)); |
| 31 | path PP; |
| 32 | for (auto& Part : in) |
| 33 | PP /= Part; |
| 34 | benchmark::DoNotOptimize(PP.native().data()); |
| 35 | while (st.KeepRunning()) { |
| 36 | const path P(PP.native().c_str()); |
| 37 | benchmark::DoNotOptimize(P.native().data()); |
| 38 | } |
| 39 | } |
| 40 | BENCHMARK_CAPTURE(BM_PathConstructCStr, large_string, |
| 41 | getRandomStringInputs)->Arg(TestNumInputs); |
| 42 | |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 43 | |
| 44 | template <template <class...> class ItType, class GenInputs> |
| 45 | void BM_PathConstructIter(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 46 | using fs::path; |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 47 | using Iter = ItType<std::string::const_iterator>; |
| 48 | const auto in = gen(st.range(0)); |
| 49 | path PP; |
| 50 | for (auto& Part : in) |
| 51 | PP /= Part; |
| 52 | auto Start = Iter(PP.native().begin()); |
| 53 | auto End = Iter(PP.native().end()); |
| 54 | benchmark::DoNotOptimize(PP.native().data()); |
| 55 | benchmark::DoNotOptimize(Start); |
| 56 | benchmark::DoNotOptimize(End); |
| 57 | while (st.KeepRunning()) { |
| 58 | const path P(Start, End); |
| 59 | benchmark::DoNotOptimize(P.native().data()); |
| 60 | } |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 61 | st.SetComplexityN(st.range(0)); |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 62 | } |
| 63 | template <class GenInputs> |
| 64 | void BM_PathConstructInputIter(benchmark::State &st, GenInputs gen) { |
| 65 | BM_PathConstructIter<input_iterator>(st, gen); |
| 66 | } |
| 67 | template <class GenInputs> |
| 68 | void BM_PathConstructForwardIter(benchmark::State &st, GenInputs gen) { |
| 69 | BM_PathConstructIter<forward_iterator>(st, gen); |
| 70 | } |
| 71 | BENCHMARK_CAPTURE(BM_PathConstructInputIter, large_string, |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 72 | getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 73 | BENCHMARK_CAPTURE(BM_PathConstructForwardIter, large_string, |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 74 | getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); |
Eric Fiselier | 026d38e | 2016-10-31 02:46:25 +0000 | [diff] [blame] | 75 | |
| 76 | |
Eric Fiselier | ad1a12c | 2016-10-30 23:53:50 +0000 | [diff] [blame] | 77 | template <class GenInputs> |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 78 | void BM_PathIterateMultipleTimes(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 79 | using fs::path; |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 80 | const auto in = gen(st.range(0)); |
| 81 | path PP; |
| 82 | for (auto& Part : in) |
| 83 | PP /= Part; |
| 84 | benchmark::DoNotOptimize(PP.native().data()); |
| 85 | while (st.KeepRunning()) { |
| 86 | for (auto &E : PP) { |
| 87 | benchmark::DoNotOptimize(E.native().data()); |
| 88 | } |
| 89 | benchmark::ClobberMemory(); |
| 90 | } |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 91 | st.SetComplexityN(st.range(0)); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 92 | } |
| 93 | BENCHMARK_CAPTURE(BM_PathIterateMultipleTimes, iterate_elements, |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 94 | getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 95 | |
| 96 | |
| 97 | template <class GenInputs> |
| 98 | void BM_PathIterateOnce(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 99 | using fs::path; |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 100 | const auto in = gen(st.range(0)); |
| 101 | path PP; |
| 102 | for (auto& Part : in) |
| 103 | PP /= Part; |
| 104 | benchmark::DoNotOptimize(PP.native().data()); |
| 105 | while (st.KeepRunning()) { |
| 106 | const path P = PP.native(); |
| 107 | for (auto &E : P) { |
| 108 | benchmark::DoNotOptimize(E.native().data()); |
| 109 | } |
| 110 | benchmark::ClobberMemory(); |
| 111 | } |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 112 | st.SetComplexityN(st.range(0)); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 113 | } |
| 114 | BENCHMARK_CAPTURE(BM_PathIterateOnce, iterate_elements, |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 115 | getRandomStringInputs)->Range(8, TestNumInputs)->Complexity(); |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 116 | |
| 117 | template <class GenInputs> |
| 118 | void BM_PathIterateOnceBackwards(benchmark::State &st, GenInputs gen) { |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 119 | using fs::path; |
Eric Fiselier | 2d2f0c0 | 2016-10-30 22:53:00 +0000 | [diff] [blame] | 120 | const auto in = gen(st.range(0)); |
| 121 | path PP; |
| 122 | for (auto& Part : in) |
| 123 | PP /= Part; |
| 124 | benchmark::DoNotOptimize(PP.native().data()); |
| 125 | while (st.KeepRunning()) { |
| 126 | const path P = PP.native(); |
| 127 | const auto B = P.begin(); |
| 128 | auto I = P.end(); |
| 129 | while (I != B) { |
| 130 | --I; |
| 131 | benchmark::DoNotOptimize(*I); |
| 132 | } |
| 133 | benchmark::DoNotOptimize(*I); |
| 134 | } |
| 135 | } |
| 136 | BENCHMARK_CAPTURE(BM_PathIterateOnceBackwards, iterate_elements, |
| 137 | getRandomStringInputs)->Arg(TestNumInputs); |
| 138 | |
Eric Fiselier | 1e34c76 | 2018-04-02 23:03:41 +0000 | [diff] [blame^] | 139 | static fs::path getRandomPaths(int NumParts, int PathLen) { |
| 140 | fs::path Result; |
| 141 | while (NumParts--) { |
| 142 | std::string Part = getRandomString(PathLen); |
| 143 | Result /= Part; |
| 144 | } |
| 145 | return Result; |
| 146 | } |
| 147 | |
| 148 | template <class GenInput> |
| 149 | void BM_LexicallyNormal(benchmark::State &st, GenInput gen, size_t PathLen) { |
| 150 | using fs::path; |
| 151 | auto In = gen(st.range(0), PathLen); |
| 152 | benchmark::DoNotOptimize(&In); |
| 153 | while (st.KeepRunning()) { |
| 154 | benchmark::DoNotOptimize(In.lexically_normal()); |
| 155 | } |
| 156 | st.SetComplexityN(st.range(0)); |
| 157 | } |
| 158 | BENCHMARK_CAPTURE(BM_LexicallyNormal, small_path, |
| 159 | getRandomPaths, /*PathLen*/5)->RangeMultiplier(2)->Range(2, 256)->Complexity(); |
| 160 | BENCHMARK_CAPTURE(BM_LexicallyNormal, large_path, |
| 161 | getRandomPaths, /*PathLen*/32)->RangeMultiplier(2)->Range(2, 256)->Complexity(); |
| 162 | |
Eric Fiselier | fd2e3e9 | 2018-01-18 04:23:01 +0000 | [diff] [blame] | 163 | BENCHMARK_MAIN(); |