#include "benchmark/benchmark.h"
#include <random>
#include <type_traits>

static thread_local std::mt19937_64 rng(std::random_device {}());

template <typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
std::vector<T> prepareRandData(int size)
{
    std::uniform_int_distribution<T> dist(1, 1000000);
    std::vector<T> result;
    for (int i = 0; i < size; ++i) {
        result.push_back(dist(rng));
    }
    return result;
}

template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
std::vector<T> prepareRandData(int size)
{
    std::uniform_real_distribution<T> dist(1, 1000000);
    std::vector<T> result;
    for (int i = 0; i < size; ++i) {
        result.push_back(dist(rng));
    }
    return result;
}

static constexpr int arrSize = 1 << 20;
static constexpr int bitmask = arrSize - 1;
static void int64_division(benchmark::State& state)
{
    std::vector a = prepareRandData<int64_t>(arrSize);
    std::vector b = prepareRandData<int64_t>(arrSize);
    int64_t i = 0, i2 = 0;
    for (auto _ : state) {
        benchmark::DoNotOptimize(a[i++ & bitmask] / b[i2++ & bitmask]);
    }
}

static void double_division(benchmark::State& state)
{
    std::vector a = prepareRandData<double>(arrSize);
    std::vector b = prepareRandData<double>(arrSize);
    int64_t i = 0, i2 = 0;
    for (auto _ : state) {
        benchmark::DoNotOptimize(a[i++ & bitmask] / b[i2++ & bitmask]);
    }
}

static void DoNothing(benchmark::State& state)
{
    while (state.KeepRunning())
        ;
}

static void BM_IntDivision(benchmark::State& state)
{
    volatile int a = 123456789;
    volatile int b = 123;
    int result;
    for (auto _ : state) {
        result = a / b;
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_IntDivision);

static void BM_FloatDivision(benchmark::State& state)
{
    volatile float a = 123456789.0f;
    volatile float b = 123.0f;
    float result;
    for (auto _ : state) {
        result = a / b;
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_FloatDivision);

static void BM_DoubleDivision(benchmark::State& state)
{
    volatile double a = 123456789.0;
    volatile double b = 123.0;
    double result;
    for (auto _ : state) {
        result = a / b;
        benchmark::DoNotOptimize(result);
    }
}
BENCHMARK(BM_DoubleDivision);

BENCHMARK(DoNothing);

BENCHMARK(int64_division);
BENCHMARK(double_division);

BENCHMARK_MAIN();