//-------------------------------------------------------------------
// buffer.cc
//-------------------------------------------------------------------

#include <array>
#include <benchmark/benchmark.h>
#include <functional>
#include <numeric>
#include <random>
#include <stdexcept>
#include <string>
#include <vector>

//-------------------------------------------------------------------

const std::size_t SIZE = 1 << 20;

int buffer[SIZE] = {0};
std::array<int, SIZE> myarray;
std::vector<int> myvector(SIZE);

int *pointer1 = buffer, *pointer2 = myarray.data(),
    *pointer3 = myvector.data(), r = 0;

struct Init
{
    Init()
    {
        std::random_device device;
        std::default_random_engine engine(device());
        std::uniform_int_distribution<> distribution;
        auto rng = std::bind(distribution, engine);

        std::generate(buffer, buffer + SIZE, rng);
        std::copy(buffer, buffer + SIZE, myarray.begin());
        std::copy(buffer, buffer + SIZE, myvector.begin());
    }
} init;

//-------------------------------------------------------------------

template<typename T> T f1(T *p, std::size_t n) { return p[n]; }

template<typename T> T f2(T *p, std::size_t n)
{
    if (n >= SIZE)
        throw std::out_of_range(std::to_string(n) +
                                " >= " + std::to_string(SIZE));
    return f1(p, n);
}

template<class T, class Container> T f1(const Container &c, std::size_t n)
{
    return c[n];
}

template<class T, class Container> T f2(const Container &c, std::size_t n)
{
    return c.at(n);
}

//-------------------------------------------------------------------

template<auto function, auto &container>
static void test(benchmark::State &state)
{
    for (auto _ : state)
    {
        r = 0;
        for (std::size_t i = 0; i < SIZE; ++i) r += function(container, i);
    }
    state.SetLabel("result = " + std::to_string(r));
}

//-------------------------------------------------------------------

BENCHMARK(test<f1<int>, buffer>);
BENCHMARK(test<f2<int>, buffer>);
BENCHMARK(test<f1<int>, pointer1>);
BENCHMARK(test<f2<int>, pointer1>);
BENCHMARK(test<f1<int, std::array<int, SIZE>>, myarray>);
BENCHMARK(test<f2<int, std::array<int, SIZE>>, myarray>);
BENCHMARK(test<f1<int>, pointer2>);
BENCHMARK(test<f2<int>, pointer2>);
BENCHMARK(test<f1<int, std::vector<int>>, myvector>);
BENCHMARK(test<f2<int, std::vector<int>>, myvector>);
BENCHMARK(test<f1<int>, pointer3>);
BENCHMARK(test<f2<int>, pointer3>);

//-------------------------------------------------------------------

BENCHMARK_MAIN();

//-------------------------------------------------------------------