forked from Research/WhisperCom
145 lines
4.1 KiB
C++
145 lines
4.1 KiB
C++
#include "catch.hpp"
|
|
|
|
#include <map>
|
|
|
|
#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
|
|
namespace {
|
|
std::uint64_t Fibonacci(std::uint64_t number) {
|
|
return number < 2 ? 1 : Fibonacci(number - 1) + Fibonacci(number - 2);
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
|
|
CHECK(Fibonacci(0) == 1);
|
|
// some more asserts..
|
|
CHECK(Fibonacci(5) == 8);
|
|
// some more asserts..
|
|
|
|
BENCHMARK("Fibonacci 20") {
|
|
return Fibonacci(20);
|
|
};
|
|
|
|
BENCHMARK("Fibonacci 25") {
|
|
return Fibonacci(25);
|
|
};
|
|
|
|
BENCHMARK("Fibonacci 30") {
|
|
return Fibonacci(30);
|
|
};
|
|
|
|
BENCHMARK("Fibonacci 35") {
|
|
return Fibonacci(35);
|
|
};
|
|
}
|
|
|
|
TEST_CASE("Benchmark containers", "[!benchmark]") {
|
|
static const int size = 100;
|
|
|
|
std::vector<int> v;
|
|
std::map<int, int> m;
|
|
|
|
SECTION("without generator") {
|
|
BENCHMARK("Load up a vector") {
|
|
v = std::vector<int>();
|
|
for (int i = 0; i < size; ++i)
|
|
v.push_back(i);
|
|
};
|
|
REQUIRE(v.size() == size);
|
|
|
|
// test optimizer control
|
|
BENCHMARK("Add up a vector's content") {
|
|
uint64_t add = 0;
|
|
for (int i = 0; i < size; ++i)
|
|
add += v[i];
|
|
return add;
|
|
};
|
|
|
|
BENCHMARK("Load up a map") {
|
|
m = std::map<int, int>();
|
|
for (int i = 0; i < size; ++i)
|
|
m.insert({ i, i + 1 });
|
|
};
|
|
REQUIRE(m.size() == size);
|
|
|
|
BENCHMARK("Reserved vector") {
|
|
v = std::vector<int>();
|
|
v.reserve(size);
|
|
for (int i = 0; i < size; ++i)
|
|
v.push_back(i);
|
|
};
|
|
REQUIRE(v.size() == size);
|
|
|
|
BENCHMARK("Resized vector") {
|
|
v = std::vector<int>();
|
|
v.resize(size);
|
|
for (int i = 0; i < size; ++i)
|
|
v[i] = i;
|
|
};
|
|
REQUIRE(v.size() == size);
|
|
|
|
int array[size];
|
|
BENCHMARK("A fixed size array that should require no allocations") {
|
|
for (int i = 0; i < size; ++i)
|
|
array[i] = i;
|
|
};
|
|
int sum = 0;
|
|
for (int i = 0; i < size; ++i)
|
|
sum += array[i];
|
|
REQUIRE(sum > size);
|
|
|
|
SECTION("XYZ") {
|
|
|
|
BENCHMARK_ADVANCED("Load up vector with chronometer")(Catch::Benchmark::Chronometer meter) {
|
|
std::vector<int> k;
|
|
meter.measure([&](int idx) {
|
|
k = std::vector<int>();
|
|
for (int i = 0; i < size; ++i)
|
|
k.push_back(idx);
|
|
});
|
|
REQUIRE(k.size() == size);
|
|
};
|
|
|
|
int runs = 0;
|
|
BENCHMARK("Fill vector indexed", benchmarkIndex) {
|
|
v = std::vector<int>();
|
|
v.resize(size);
|
|
for (int i = 0; i < size; ++i)
|
|
v[i] = benchmarkIndex;
|
|
runs = benchmarkIndex;
|
|
};
|
|
|
|
for (size_t i = 0; i < v.size(); ++i) {
|
|
REQUIRE(v[i] == runs);
|
|
}
|
|
}
|
|
}
|
|
|
|
SECTION("with generator") {
|
|
auto generated = GENERATE(range(0, 10));
|
|
BENCHMARK("Fill vector generated") {
|
|
v = std::vector<int>();
|
|
v.resize(size);
|
|
for (int i = 0; i < size; ++i)
|
|
v[i] = generated;
|
|
};
|
|
for (size_t i = 0; i < v.size(); ++i) {
|
|
REQUIRE(v[i] == generated);
|
|
}
|
|
}
|
|
|
|
SECTION("construct and destroy example") {
|
|
BENCHMARK_ADVANCED("construct")(Catch::Benchmark::Chronometer meter) {
|
|
std::vector<Catch::Benchmark::storage_for<std::string>> storage(meter.runs());
|
|
meter.measure([&](int i) { storage[i].construct("thing"); });
|
|
};
|
|
|
|
BENCHMARK_ADVANCED("destroy")(Catch::Benchmark::Chronometer meter) {
|
|
std::vector<Catch::Benchmark::destructable_object<std::string>> storage(meter.runs());
|
|
for(auto&& o : storage)
|
|
o.construct("thing");
|
|
meter.measure([&](int i) { storage[i].destruct(); });
|
|
};
|
|
}
|
|
}
|
|
#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
|