catch2/projects/SelfTest/UsageTests/Benchmark.tests.cpp

#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