98 lines
2.4 KiB
C++
98 lines
2.4 KiB
C++
#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(); |