131 lines
4.1 KiB
C++
131 lines
4.1 KiB
C++
// (C) Copyright Nick Thompson and Matt Borland 2020.
|
|
// Use, modification and distribution are subject to the
|
|
// Boost Software License, Version 1.0. (See accompanying file
|
|
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#include <random>
|
|
#include <boost/math/statistics/univariate_statistics.hpp>
|
|
#include <benchmark/benchmark.h>
|
|
|
|
template <class Z>
|
|
void test_mode(benchmark::State& state)
|
|
{
|
|
using boost::math::statistics::sorted_mode;
|
|
|
|
std::random_device rd;
|
|
std::mt19937_64 mt(rd());
|
|
std::uniform_int_distribution<> dist {1, 10};
|
|
|
|
auto gen = [&dist, &mt](){return dist(mt);};
|
|
|
|
std::vector<Z> v(state.range(0));
|
|
std::generate(v.begin(), v.end(), gen);
|
|
|
|
for (auto _ : state)
|
|
{
|
|
std::vector<Z> modes;
|
|
benchmark::DoNotOptimize(sorted_mode(v.begin(), v.end(), std::back_inserter(modes)));
|
|
}
|
|
|
|
state.SetComplexityN(state.range(0));
|
|
}
|
|
|
|
template <class Z>
|
|
void sequential_test_mode(benchmark::State& state)
|
|
{
|
|
using boost::math::statistics::sorted_mode;
|
|
|
|
std::vector<Z> v(state.range(0));
|
|
|
|
size_t current_num {1};
|
|
// produces {1, 2, 3, 4, 5...}
|
|
for(size_t i {}; i < v.size(); ++i)
|
|
{
|
|
v[i] = current_num;
|
|
++current_num;
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
std::vector<Z> modes;
|
|
benchmark::DoNotOptimize(sorted_mode(v, std::back_inserter(modes)));
|
|
}
|
|
|
|
state.SetComplexityN(state.range(0));
|
|
}
|
|
|
|
template <class Z>
|
|
void sequential_pairs_test_mode(benchmark::State& state)
|
|
{
|
|
using boost::math::statistics::sorted_mode;
|
|
|
|
std::vector<Z> v(state.range(0));
|
|
|
|
size_t current_num {1};
|
|
size_t current_num_counter {};
|
|
// produces {1, 1, 2, 2, 3, 3, ...}
|
|
for(size_t i {}; i < v.size(); ++i)
|
|
{
|
|
v[i] = current_num;
|
|
++current_num_counter;
|
|
if(current_num_counter > 2)
|
|
{
|
|
++current_num;
|
|
current_num_counter = 0;
|
|
}
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
std::vector<Z> modes;
|
|
benchmark::DoNotOptimize(sorted_mode(v, std::back_inserter(modes)));
|
|
}
|
|
|
|
state.SetComplexityN(state.range(0));
|
|
}
|
|
|
|
template <class Z>
|
|
void sequential_multiple_test_mode(benchmark::State& state)
|
|
{
|
|
using boost::math::statistics::sorted_mode;
|
|
|
|
std::vector<Z> v(state.range(0));
|
|
|
|
size_t current_num {1};
|
|
size_t current_num_counter {};
|
|
// produces {1, 2, 2, 3, 3, 3, 4, 4, 4, 4, ...}
|
|
for(size_t i {}; i < v.size(); ++i)
|
|
{
|
|
v[i] = current_num;
|
|
++current_num_counter;
|
|
if(current_num_counter > current_num)
|
|
{
|
|
++current_num;
|
|
current_num_counter = 0;
|
|
}
|
|
}
|
|
|
|
for (auto _ : state)
|
|
{
|
|
std::vector<Z> modes;
|
|
benchmark::DoNotOptimize(sorted_mode(v, std::back_inserter(modes)));
|
|
}
|
|
|
|
state.SetComplexityN(state.range(0));
|
|
}
|
|
|
|
BENCHMARK_TEMPLATE(test_mode, int32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(test_mode, int64_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(test_mode, uint32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_test_mode, int32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_test_mode, int64_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_test_mode, uint32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_pairs_test_mode, int32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_pairs_test_mode, int64_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_pairs_test_mode, uint32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_multiple_test_mode, int32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_multiple_test_mode, int64_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
BENCHMARK_TEMPLATE(sequential_multiple_test_mode, uint32_t)->RangeMultiplier(2)->Range(1<<1, 1<<22)->Complexity();
|
|
|
|
BENCHMARK_MAIN();
|