1 #include "catch.hpp"
2 
3 #include <map>
4 
5 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
6 namespace {
Fibonacci(std::uint64_t number)7     std::uint64_t Fibonacci(std::uint64_t number) {
8         return number < 2 ? 1 : Fibonacci(number - 1) + Fibonacci(number - 2);
9     }
10 }
11 
12 TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
13     CHECK(Fibonacci(0) == 1);
14     // some more asserts..
15     CHECK(Fibonacci(5) == 8);
16     // some more asserts..
17 
18     BENCHMARK("Fibonacci 20") {
19         return Fibonacci(20);
20     };
21 
22     BENCHMARK("Fibonacci 25") {
23         return Fibonacci(25);
24     };
25 
26     BENCHMARK("Fibonacci 30") {
27         return Fibonacci(30);
28     };
29 
30     BENCHMARK("Fibonacci 35") {
31         return Fibonacci(35);
32     };
33 }
34 
35 TEST_CASE("Benchmark containers", "[!benchmark]") {
36     static const int size = 100;
37 
38     std::vector<int> v;
39     std::map<int, int> m;
40 
41     SECTION("without generator") {
42         BENCHMARK("Load up a vector") {
43             v = std::vector<int>();
44             for (int i = 0; i < size; ++i)
45                 v.push_back(i);
46         };
47         REQUIRE(v.size() == size);
48 
49         // test optimizer control
50         BENCHMARK("Add up a vector's content") {
51             uint64_t add = 0;
52             for (int i = 0; i < size; ++i)
53                 add += v[i];
54             return add;
55         };
56 
57         BENCHMARK("Load up a map") {
58             m = std::map<int, int>();
59             for (int i = 0; i < size; ++i)
60                 m.insert({ i, i + 1 });
61         };
62         REQUIRE(m.size() == size);
63 
64         BENCHMARK("Reserved vector") {
65             v = std::vector<int>();
66             v.reserve(size);
67             for (int i = 0; i < size; ++i)
68                 v.push_back(i);
69         };
70         REQUIRE(v.size() == size);
71 
72         BENCHMARK("Resized vector") {
73             v = std::vector<int>();
74             v.resize(size);
75             for (int i = 0; i < size; ++i)
76                 v[i] = i;
77         };
78         REQUIRE(v.size() == size);
79 
80         int array[size];
81         BENCHMARK("A fixed size array that should require no allocations") {
82             for (int i = 0; i < size; ++i)
83                 array[i] = i;
84         };
85         int sum = 0;
86         for (int i = 0; i < size; ++i)
87             sum += array[i];
88         REQUIRE(sum > size);
89 
90         SECTION("XYZ") {
91 
92             BENCHMARK_ADVANCED("Load up vector with chronometer")(Catch::Benchmark::Chronometer meter) {
93                 std::vector<int> k;
__anondaafaadb0202(int idx) 94                 meter.measure([&](int idx) {
95                     k = std::vector<int>();
96                     for (int i = 0; i < size; ++i)
97                         k.push_back(idx);
98                 });
99                 REQUIRE(k.size() == size);
100             };
101 
102             int runs = 0;
103             BENCHMARK("Fill vector indexed", benchmarkIndex) {
104                 v = std::vector<int>();
105                 v.resize(size);
106                 for (int i = 0; i < size; ++i)
107                     v[i] = benchmarkIndex;
108                 runs = benchmarkIndex;
109             };
110 
111             for (size_t i = 0; i < v.size(); ++i) {
112                 REQUIRE(v[i] == runs);
113             }
114         }
115     }
116 
117     SECTION("with generator") {
118         auto generated = GENERATE(range(0, 10));
119         BENCHMARK("Fill vector generated") {
120             v = std::vector<int>();
121             v.resize(size);
122             for (int i = 0; i < size; ++i)
123                 v[i] = generated;
124         };
125         for (size_t i = 0; i < v.size(); ++i) {
126             REQUIRE(v[i] == generated);
127         }
128     }
129 
130     SECTION("construct and destroy example") {
131         BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter) {
132             std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
__anondaafaadb0302(int i) 133             meter.measure([&](int i) { storage[i].construct("thing"); });
134         };
135 
136         BENCHMARK_ADVANCED("destroy")(Catch::Benchmark::Chronometer meter) {
137             std::vector<Catch::Benchmark::destructable_object<std::string>> storage(meter.runs());
138             for(auto&& o : storage)
139                 o.construct("thing");
__anondaafaadb0402(int i) 140             meter.measure([&](int i) { storage[i].destruct(); });
141         };
142     }
143 }
144 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
145