740 lines
27 KiB
C++
740 lines
27 KiB
C++
// Copyright 2018 The Abseil Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <numeric>
|
|
#include <random>
|
|
#include <set>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
#include "benchmark/benchmark.h"
|
|
#include "absl/base/internal/raw_logging.h"
|
|
#include "absl/container/btree_map.h"
|
|
#include "absl/container/btree_set.h"
|
|
#include "absl/container/btree_test.h"
|
|
#include "absl/container/flat_hash_map.h"
|
|
#include "absl/container/flat_hash_set.h"
|
|
#include "absl/container/internal/hashtable_debug.h"
|
|
#include "absl/flags/flag.h"
|
|
#include "absl/hash/hash.h"
|
|
#include "absl/memory/memory.h"
|
|
#include "absl/strings/cord.h"
|
|
#include "absl/strings/str_format.h"
|
|
#include "absl/time/time.h"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
namespace container_internal {
|
|
namespace {
|
|
|
|
constexpr size_t kBenchmarkValues = 1 << 20;
|
|
|
|
// How many times we add and remove sub-batches in one batch of *AddRem
|
|
// benchmarks.
|
|
constexpr size_t kAddRemBatchSize = 1 << 2;
|
|
|
|
// Generates n values in the range [0, 4 * n].
|
|
template <typename V>
|
|
std::vector<V> GenerateValues(int n) {
|
|
constexpr int kSeed = 23;
|
|
return GenerateValuesWithSeed<V>(n, 4 * n, kSeed);
|
|
}
|
|
|
|
// Benchmark insertion of values into a container.
|
|
template <typename T>
|
|
void BM_InsertImpl(benchmark::State& state, bool sorted) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
if (sorted) {
|
|
std::sort(values.begin(), values.end());
|
|
}
|
|
T container(values.begin(), values.end());
|
|
|
|
// Remove and re-insert 10% of the keys per batch.
|
|
const int batch_size = (kBenchmarkValues + 9) / 10;
|
|
while (state.KeepRunningBatch(batch_size)) {
|
|
state.PauseTiming();
|
|
const auto i = static_cast<int>(state.iterations());
|
|
|
|
for (int j = i; j < i + batch_size; j++) {
|
|
int x = j % kBenchmarkValues;
|
|
container.erase(key_of_value(values[x]));
|
|
}
|
|
|
|
state.ResumeTiming();
|
|
|
|
for (int j = i; j < i + batch_size; j++) {
|
|
int x = j % kBenchmarkValues;
|
|
container.insert(values[x]);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void BM_Insert(benchmark::State& state) {
|
|
BM_InsertImpl<T>(state, false);
|
|
}
|
|
|
|
template <typename T>
|
|
void BM_InsertSorted(benchmark::State& state) {
|
|
BM_InsertImpl<T>(state, true);
|
|
}
|
|
|
|
// Benchmark inserting the first few elements in a container. In b-tree, this is
|
|
// when the root node grows.
|
|
template <typename T>
|
|
void BM_InsertSmall(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
|
|
const int kSize = 8;
|
|
std::vector<V> values = GenerateValues<V>(kSize);
|
|
T container;
|
|
|
|
while (state.KeepRunningBatch(kSize)) {
|
|
for (int i = 0; i < kSize; ++i) {
|
|
benchmark::DoNotOptimize(container.insert(values[i]));
|
|
}
|
|
state.PauseTiming();
|
|
// Do not measure the time it takes to clear the container.
|
|
container.clear();
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void BM_LookupImpl(benchmark::State& state, bool sorted) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
if (sorted) {
|
|
std::sort(values.begin(), values.end());
|
|
}
|
|
T container(values.begin(), values.end());
|
|
|
|
while (state.KeepRunning()) {
|
|
int idx = state.iterations() % kBenchmarkValues;
|
|
benchmark::DoNotOptimize(container.find(key_of_value(values[idx])));
|
|
}
|
|
}
|
|
|
|
// Benchmark lookup of values in a container.
|
|
template <typename T>
|
|
void BM_Lookup(benchmark::State& state) {
|
|
BM_LookupImpl<T>(state, false);
|
|
}
|
|
|
|
// Benchmark lookup of values in a full container, meaning that values
|
|
// are inserted in-order to take advantage of biased insertion, which
|
|
// yields a full tree.
|
|
template <typename T>
|
|
void BM_FullLookup(benchmark::State& state) {
|
|
BM_LookupImpl<T>(state, true);
|
|
}
|
|
|
|
// Benchmark erasing values from a container.
|
|
template <typename T>
|
|
void BM_Erase(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
T container(values.begin(), values.end());
|
|
|
|
// Remove and re-insert 10% of the keys per batch.
|
|
const int batch_size = (kBenchmarkValues + 9) / 10;
|
|
while (state.KeepRunningBatch(batch_size)) {
|
|
const int i = state.iterations();
|
|
|
|
for (int j = i; j < i + batch_size; j++) {
|
|
int x = j % kBenchmarkValues;
|
|
container.erase(key_of_value(values[x]));
|
|
}
|
|
|
|
state.PauseTiming();
|
|
for (int j = i; j < i + batch_size; j++) {
|
|
int x = j % kBenchmarkValues;
|
|
container.insert(values[x]);
|
|
}
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
// Benchmark erasing multiple values from a container.
|
|
template <typename T>
|
|
void BM_EraseRange(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
T container(values.begin(), values.end());
|
|
|
|
// Remove and re-insert 10% of the keys per batch.
|
|
const int batch_size = (kBenchmarkValues + 9) / 10;
|
|
while (state.KeepRunningBatch(batch_size)) {
|
|
const int i = state.iterations();
|
|
|
|
const int start_index = i % kBenchmarkValues;
|
|
|
|
state.PauseTiming();
|
|
{
|
|
std::vector<V> removed;
|
|
removed.reserve(batch_size);
|
|
auto itr = container.find(key_of_value(values[start_index]));
|
|
auto start = itr;
|
|
for (int j = 0; j < batch_size; j++) {
|
|
if (itr == container.end()) {
|
|
state.ResumeTiming();
|
|
container.erase(start, itr);
|
|
state.PauseTiming();
|
|
itr = container.begin();
|
|
start = itr;
|
|
}
|
|
removed.push_back(*itr++);
|
|
}
|
|
|
|
state.ResumeTiming();
|
|
container.erase(start, itr);
|
|
state.PauseTiming();
|
|
|
|
container.insert(removed.begin(), removed.end());
|
|
}
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
// Predicate that erases every other element. We can't use a lambda because
|
|
// C++11 doesn't support generic lambdas.
|
|
// TODO(b/207389011): consider adding benchmarks that remove different fractions
|
|
// of keys (e.g. 10%, 90%).
|
|
struct EraseIfPred {
|
|
uint64_t i = 0;
|
|
template <typename T>
|
|
bool operator()(const T&) {
|
|
return ++i % 2;
|
|
}
|
|
};
|
|
|
|
// Benchmark erasing multiple values from a container with a predicate.
|
|
template <typename T>
|
|
void BM_EraseIf(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
|
|
// Removes half of the keys per batch.
|
|
const int batch_size = (kBenchmarkValues + 1) / 2;
|
|
EraseIfPred pred;
|
|
while (state.KeepRunningBatch(batch_size)) {
|
|
state.PauseTiming();
|
|
{
|
|
T container(values.begin(), values.end());
|
|
state.ResumeTiming();
|
|
erase_if(container, pred);
|
|
benchmark::DoNotOptimize(container);
|
|
state.PauseTiming();
|
|
}
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
// Benchmark steady-state insert (into first half of range) and remove (from
|
|
// second half of range), treating the container approximately like a queue with
|
|
// log-time access for all elements. This benchmark does not test the case where
|
|
// insertion and removal happen in the same region of the tree. This benchmark
|
|
// counts two value constructors.
|
|
template <typename T>
|
|
void BM_QueueAddRem(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
|
|
ABSL_RAW_CHECK(kBenchmarkValues % 2 == 0, "for performance");
|
|
|
|
T container;
|
|
|
|
const size_t half = kBenchmarkValues / 2;
|
|
std::vector<int> remove_keys(half);
|
|
std::vector<int> add_keys(half);
|
|
|
|
// We want to do the exact same work repeatedly, and the benchmark can end
|
|
// after a different number of iterations depending on the speed of the
|
|
// individual run so we use a large batch size here and ensure that we do
|
|
// deterministic work every batch.
|
|
while (state.KeepRunningBatch(half * kAddRemBatchSize)) {
|
|
state.PauseTiming();
|
|
|
|
container.clear();
|
|
|
|
for (size_t i = 0; i < half; ++i) {
|
|
remove_keys[i] = i;
|
|
add_keys[i] = i;
|
|
}
|
|
constexpr int kSeed = 5;
|
|
std::mt19937_64 rand(kSeed);
|
|
std::shuffle(remove_keys.begin(), remove_keys.end(), rand);
|
|
std::shuffle(add_keys.begin(), add_keys.end(), rand);
|
|
|
|
// Note needs lazy generation of values.
|
|
Generator<V> g(kBenchmarkValues * kAddRemBatchSize);
|
|
|
|
for (size_t i = 0; i < half; ++i) {
|
|
container.insert(g(add_keys[i]));
|
|
container.insert(g(half + remove_keys[i]));
|
|
}
|
|
|
|
// There are three parts each of size "half":
|
|
// 1 is being deleted from [offset - half, offset)
|
|
// 2 is standing [offset, offset + half)
|
|
// 3 is being inserted into [offset + half, offset + 2 * half)
|
|
size_t offset = 0;
|
|
|
|
for (size_t i = 0; i < kAddRemBatchSize; ++i) {
|
|
std::shuffle(remove_keys.begin(), remove_keys.end(), rand);
|
|
std::shuffle(add_keys.begin(), add_keys.end(), rand);
|
|
offset += half;
|
|
|
|
state.ResumeTiming();
|
|
for (size_t idx = 0; idx < half; ++idx) {
|
|
container.erase(key_of_value(g(offset - half + remove_keys[idx])));
|
|
container.insert(g(offset + half + add_keys[idx]));
|
|
}
|
|
state.PauseTiming();
|
|
}
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
// Mixed insertion and deletion in the same range using pre-constructed values.
|
|
template <typename T>
|
|
void BM_MixedAddRem(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
typename KeyOfValue<typename T::key_type, V>::type key_of_value;
|
|
|
|
ABSL_RAW_CHECK(kBenchmarkValues % 2 == 0, "for performance");
|
|
|
|
T container;
|
|
|
|
// Create two random shuffles
|
|
std::vector<int> remove_keys(kBenchmarkValues);
|
|
std::vector<int> add_keys(kBenchmarkValues);
|
|
|
|
// We want to do the exact same work repeatedly, and the benchmark can end
|
|
// after a different number of iterations depending on the speed of the
|
|
// individual run so we use a large batch size here and ensure that we do
|
|
// deterministic work every batch.
|
|
while (state.KeepRunningBatch(kBenchmarkValues * kAddRemBatchSize)) {
|
|
state.PauseTiming();
|
|
|
|
container.clear();
|
|
|
|
constexpr int kSeed = 7;
|
|
std::mt19937_64 rand(kSeed);
|
|
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues * 2);
|
|
|
|
// Insert the first half of the values (already in random order)
|
|
container.insert(values.begin(), values.begin() + kBenchmarkValues);
|
|
|
|
// Insert the first half of the values (already in random order)
|
|
for (size_t i = 0; i < kBenchmarkValues; ++i) {
|
|
// remove_keys and add_keys will be swapped before each round,
|
|
// therefore fill add_keys here w/ the keys being inserted, so
|
|
// they'll be the first to be removed.
|
|
remove_keys[i] = i + kBenchmarkValues;
|
|
add_keys[i] = i;
|
|
}
|
|
|
|
for (size_t i = 0; i < kAddRemBatchSize; ++i) {
|
|
remove_keys.swap(add_keys);
|
|
std::shuffle(remove_keys.begin(), remove_keys.end(), rand);
|
|
std::shuffle(add_keys.begin(), add_keys.end(), rand);
|
|
|
|
state.ResumeTiming();
|
|
for (size_t idx = 0; idx < kBenchmarkValues; ++idx) {
|
|
container.erase(key_of_value(values[remove_keys[idx]]));
|
|
container.insert(values[add_keys[idx]]);
|
|
}
|
|
state.PauseTiming();
|
|
}
|
|
state.ResumeTiming();
|
|
}
|
|
}
|
|
|
|
// Insertion at end, removal from the beginning. This benchmark
|
|
// counts two value constructors.
|
|
// TODO(ezb): we could add a GenerateNext version of generator that could reduce
|
|
// noise for string-like types.
|
|
template <typename T>
|
|
void BM_Fifo(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
|
|
T container;
|
|
// Need lazy generation of values as state.max_iterations is large.
|
|
Generator<V> g(kBenchmarkValues + state.max_iterations);
|
|
|
|
for (int i = 0; i < kBenchmarkValues; i++) {
|
|
container.insert(g(i));
|
|
}
|
|
|
|
while (state.KeepRunning()) {
|
|
container.erase(container.begin());
|
|
container.insert(container.end(), g(state.iterations() + kBenchmarkValues));
|
|
}
|
|
}
|
|
|
|
// Iteration (forward) through the tree
|
|
template <typename T>
|
|
void BM_FwdIter(benchmark::State& state) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
using R = typename T::value_type const*;
|
|
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
T container(values.begin(), values.end());
|
|
|
|
auto iter = container.end();
|
|
|
|
R r = nullptr;
|
|
|
|
while (state.KeepRunning()) {
|
|
if (iter == container.end()) iter = container.begin();
|
|
r = &(*iter);
|
|
++iter;
|
|
}
|
|
|
|
benchmark::DoNotOptimize(r);
|
|
}
|
|
|
|
// Benchmark random range-construction of a container.
|
|
template <typename T>
|
|
void BM_RangeConstructionImpl(benchmark::State& state, bool sorted) {
|
|
using V = typename remove_pair_const<typename T::value_type>::type;
|
|
|
|
std::vector<V> values = GenerateValues<V>(kBenchmarkValues);
|
|
if (sorted) {
|
|
std::sort(values.begin(), values.end());
|
|
}
|
|
{
|
|
T container(values.begin(), values.end());
|
|
}
|
|
|
|
while (state.KeepRunning()) {
|
|
T container(values.begin(), values.end());
|
|
benchmark::DoNotOptimize(container);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void BM_InsertRangeRandom(benchmark::State& state) {
|
|
BM_RangeConstructionImpl<T>(state, false);
|
|
}
|
|
|
|
template <typename T>
|
|
void BM_InsertRangeSorted(benchmark::State& state) {
|
|
BM_RangeConstructionImpl<T>(state, true);
|
|
}
|
|
|
|
#define STL_ORDERED_TYPES(value) \
|
|
using stl_set_##value = std::set<value>; \
|
|
using stl_map_##value = std::map<value, intptr_t>; \
|
|
using stl_multiset_##value = std::multiset<value>; \
|
|
using stl_multimap_##value = std::multimap<value, intptr_t>
|
|
|
|
using StdString = std::string;
|
|
STL_ORDERED_TYPES(int32_t);
|
|
STL_ORDERED_TYPES(int64_t);
|
|
STL_ORDERED_TYPES(StdString);
|
|
STL_ORDERED_TYPES(Cord);
|
|
STL_ORDERED_TYPES(Time);
|
|
|
|
#define STL_UNORDERED_TYPES(value) \
|
|
using stl_unordered_set_##value = std::unordered_set<value>; \
|
|
using stl_unordered_map_##value = std::unordered_map<value, intptr_t>; \
|
|
using flat_hash_set_##value = flat_hash_set<value>; \
|
|
using flat_hash_map_##value = flat_hash_map<value, intptr_t>; \
|
|
using stl_unordered_multiset_##value = std::unordered_multiset<value>; \
|
|
using stl_unordered_multimap_##value = \
|
|
std::unordered_multimap<value, intptr_t>
|
|
|
|
#define STL_UNORDERED_TYPES_CUSTOM_HASH(value, hash) \
|
|
using stl_unordered_set_##value = std::unordered_set<value, hash>; \
|
|
using stl_unordered_map_##value = std::unordered_map<value, intptr_t, hash>; \
|
|
using flat_hash_set_##value = flat_hash_set<value, hash>; \
|
|
using flat_hash_map_##value = flat_hash_map<value, intptr_t, hash>; \
|
|
using stl_unordered_multiset_##value = std::unordered_multiset<value, hash>; \
|
|
using stl_unordered_multimap_##value = \
|
|
std::unordered_multimap<value, intptr_t, hash>
|
|
|
|
STL_UNORDERED_TYPES_CUSTOM_HASH(Cord, absl::Hash<absl::Cord>);
|
|
|
|
STL_UNORDERED_TYPES(int32_t);
|
|
STL_UNORDERED_TYPES(int64_t);
|
|
STL_UNORDERED_TYPES(StdString);
|
|
STL_UNORDERED_TYPES_CUSTOM_HASH(Time, absl::Hash<absl::Time>);
|
|
|
|
#define BTREE_TYPES(value) \
|
|
using btree_256_set_##value = \
|
|
btree_set<value, std::less<value>, std::allocator<value>>; \
|
|
using btree_256_map_##value = \
|
|
btree_map<value, intptr_t, std::less<value>, \
|
|
std::allocator<std::pair<const value, intptr_t>>>; \
|
|
using btree_256_multiset_##value = \
|
|
btree_multiset<value, std::less<value>, std::allocator<value>>; \
|
|
using btree_256_multimap_##value = \
|
|
btree_multimap<value, intptr_t, std::less<value>, \
|
|
std::allocator<std::pair<const value, intptr_t>>>
|
|
|
|
BTREE_TYPES(int32_t);
|
|
BTREE_TYPES(int64_t);
|
|
BTREE_TYPES(StdString);
|
|
BTREE_TYPES(Cord);
|
|
BTREE_TYPES(Time);
|
|
|
|
#define MY_BENCHMARK4(type, func) \
|
|
void BM_##type##_##func(benchmark::State& state) { BM_##func<type>(state); } \
|
|
BENCHMARK(BM_##type##_##func)
|
|
|
|
#define MY_BENCHMARK3_STL(type) \
|
|
MY_BENCHMARK4(type, Insert); \
|
|
MY_BENCHMARK4(type, InsertSorted); \
|
|
MY_BENCHMARK4(type, InsertSmall); \
|
|
MY_BENCHMARK4(type, Lookup); \
|
|
MY_BENCHMARK4(type, FullLookup); \
|
|
MY_BENCHMARK4(type, Erase); \
|
|
MY_BENCHMARK4(type, EraseRange); \
|
|
MY_BENCHMARK4(type, QueueAddRem); \
|
|
MY_BENCHMARK4(type, MixedAddRem); \
|
|
MY_BENCHMARK4(type, Fifo); \
|
|
MY_BENCHMARK4(type, FwdIter); \
|
|
MY_BENCHMARK4(type, InsertRangeRandom); \
|
|
MY_BENCHMARK4(type, InsertRangeSorted)
|
|
|
|
#define MY_BENCHMARK3(type) \
|
|
MY_BENCHMARK4(type, EraseIf); \
|
|
MY_BENCHMARK3_STL(type)
|
|
|
|
#define MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(type) \
|
|
MY_BENCHMARK3_STL(stl_##type); \
|
|
MY_BENCHMARK3_STL(stl_unordered_##type); \
|
|
MY_BENCHMARK3(btree_256_##type)
|
|
|
|
#define MY_BENCHMARK2(type) \
|
|
MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(type); \
|
|
MY_BENCHMARK3(flat_hash_##type)
|
|
|
|
// Define MULTI_TESTING to see benchmarks for multi-containers also.
|
|
//
|
|
// You can use --copt=-DMULTI_TESTING.
|
|
#ifdef MULTI_TESTING
|
|
#define MY_BENCHMARK(type) \
|
|
MY_BENCHMARK2(set_##type); \
|
|
MY_BENCHMARK2(map_##type); \
|
|
MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(multiset_##type); \
|
|
MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(multimap_##type)
|
|
#else
|
|
#define MY_BENCHMARK(type) \
|
|
MY_BENCHMARK2(set_##type); \
|
|
MY_BENCHMARK2(map_##type)
|
|
#endif
|
|
|
|
MY_BENCHMARK(int32_t);
|
|
MY_BENCHMARK(int64_t);
|
|
MY_BENCHMARK(StdString);
|
|
MY_BENCHMARK(Cord);
|
|
MY_BENCHMARK(Time);
|
|
|
|
// Define a type whose size and cost of moving are independently customizable.
|
|
// When sizeof(value_type) increases, we expect btree to no longer have as much
|
|
// cache-locality advantage over STL. When cost of moving increases, we expect
|
|
// btree to actually do more work than STL because it has to move values around
|
|
// and STL doesn't have to.
|
|
template <int Size, int Copies>
|
|
struct BigType {
|
|
BigType() : BigType(0) {}
|
|
explicit BigType(int x) { std::iota(values.begin(), values.end(), x); }
|
|
|
|
void Copy(const BigType& other) {
|
|
for (int i = 0; i < Size && i < Copies; ++i) values[i] = other.values[i];
|
|
// If Copies > Size, do extra copies.
|
|
for (int i = Size, idx = 0; i < Copies; ++i) {
|
|
int64_t tmp = other.values[idx];
|
|
benchmark::DoNotOptimize(tmp);
|
|
idx = idx + 1 == Size ? 0 : idx + 1;
|
|
}
|
|
}
|
|
|
|
BigType(const BigType& other) { Copy(other); }
|
|
BigType& operator=(const BigType& other) {
|
|
Copy(other);
|
|
return *this;
|
|
}
|
|
|
|
// Compare only the first Copies elements if Copies is less than Size.
|
|
bool operator<(const BigType& other) const {
|
|
return std::lexicographical_compare(
|
|
values.begin(), values.begin() + std::min(Size, Copies),
|
|
other.values.begin(), other.values.begin() + std::min(Size, Copies));
|
|
}
|
|
bool operator==(const BigType& other) const {
|
|
return std::equal(values.begin(), values.begin() + std::min(Size, Copies),
|
|
other.values.begin());
|
|
}
|
|
|
|
// Support absl::Hash.
|
|
template <typename State>
|
|
friend State AbslHashValue(State h, const BigType& b) {
|
|
for (int i = 0; i < Size && i < Copies; ++i)
|
|
h = State::combine(std::move(h), b.values[i]);
|
|
return h;
|
|
}
|
|
|
|
std::array<int64_t, Size> values;
|
|
};
|
|
|
|
#define BIG_TYPE_BENCHMARKS(SIZE, COPIES) \
|
|
using stl_set_size##SIZE##copies##COPIES = std::set<BigType<SIZE, COPIES>>; \
|
|
using stl_map_size##SIZE##copies##COPIES = \
|
|
std::map<BigType<SIZE, COPIES>, intptr_t>; \
|
|
using stl_multiset_size##SIZE##copies##COPIES = \
|
|
std::multiset<BigType<SIZE, COPIES>>; \
|
|
using stl_multimap_size##SIZE##copies##COPIES = \
|
|
std::multimap<BigType<SIZE, COPIES>, intptr_t>; \
|
|
using stl_unordered_set_size##SIZE##copies##COPIES = \
|
|
std::unordered_set<BigType<SIZE, COPIES>, \
|
|
absl::Hash<BigType<SIZE, COPIES>>>; \
|
|
using stl_unordered_map_size##SIZE##copies##COPIES = \
|
|
std::unordered_map<BigType<SIZE, COPIES>, intptr_t, \
|
|
absl::Hash<BigType<SIZE, COPIES>>>; \
|
|
using flat_hash_set_size##SIZE##copies##COPIES = \
|
|
flat_hash_set<BigType<SIZE, COPIES>>; \
|
|
using flat_hash_map_size##SIZE##copies##COPIES = \
|
|
flat_hash_map<BigType<SIZE, COPIES>, intptr_t>; \
|
|
using stl_unordered_multiset_size##SIZE##copies##COPIES = \
|
|
std::unordered_multiset<BigType<SIZE, COPIES>, \
|
|
absl::Hash<BigType<SIZE, COPIES>>>; \
|
|
using stl_unordered_multimap_size##SIZE##copies##COPIES = \
|
|
std::unordered_multimap<BigType<SIZE, COPIES>, intptr_t, \
|
|
absl::Hash<BigType<SIZE, COPIES>>>; \
|
|
using btree_256_set_size##SIZE##copies##COPIES = \
|
|
btree_set<BigType<SIZE, COPIES>>; \
|
|
using btree_256_map_size##SIZE##copies##COPIES = \
|
|
btree_map<BigType<SIZE, COPIES>, intptr_t>; \
|
|
using btree_256_multiset_size##SIZE##copies##COPIES = \
|
|
btree_multiset<BigType<SIZE, COPIES>>; \
|
|
using btree_256_multimap_size##SIZE##copies##COPIES = \
|
|
btree_multimap<BigType<SIZE, COPIES>, intptr_t>; \
|
|
MY_BENCHMARK(size##SIZE##copies##COPIES)
|
|
|
|
// Define BIG_TYPE_TESTING to see benchmarks for more big types.
|
|
//
|
|
// You can use --copt=-DBIG_TYPE_TESTING.
|
|
#ifndef NODESIZE_TESTING
|
|
#ifdef BIG_TYPE_TESTING
|
|
BIG_TYPE_BENCHMARKS(1, 4);
|
|
BIG_TYPE_BENCHMARKS(4, 1);
|
|
BIG_TYPE_BENCHMARKS(4, 4);
|
|
BIG_TYPE_BENCHMARKS(1, 8);
|
|
BIG_TYPE_BENCHMARKS(8, 1);
|
|
BIG_TYPE_BENCHMARKS(8, 8);
|
|
BIG_TYPE_BENCHMARKS(1, 16);
|
|
BIG_TYPE_BENCHMARKS(16, 1);
|
|
BIG_TYPE_BENCHMARKS(16, 16);
|
|
BIG_TYPE_BENCHMARKS(1, 32);
|
|
BIG_TYPE_BENCHMARKS(32, 1);
|
|
BIG_TYPE_BENCHMARKS(32, 32);
|
|
#else
|
|
BIG_TYPE_BENCHMARKS(32, 32);
|
|
#endif
|
|
#endif
|
|
|
|
// Benchmark using unique_ptrs to large value types. In order to be able to use
|
|
// the same benchmark code as the other types, use a type that holds a
|
|
// unique_ptr and has a copy constructor.
|
|
template <int Size>
|
|
struct BigTypePtr {
|
|
BigTypePtr() : BigTypePtr(0) {}
|
|
explicit BigTypePtr(int x) {
|
|
ptr = absl::make_unique<BigType<Size, Size>>(x);
|
|
}
|
|
BigTypePtr(const BigTypePtr& other) {
|
|
ptr = absl::make_unique<BigType<Size, Size>>(*other.ptr);
|
|
}
|
|
BigTypePtr(BigTypePtr&& other) noexcept = default;
|
|
BigTypePtr& operator=(const BigTypePtr& other) {
|
|
ptr = absl::make_unique<BigType<Size, Size>>(*other.ptr);
|
|
}
|
|
BigTypePtr& operator=(BigTypePtr&& other) noexcept = default;
|
|
|
|
bool operator<(const BigTypePtr& other) const { return *ptr < *other.ptr; }
|
|
bool operator==(const BigTypePtr& other) const { return *ptr == *other.ptr; }
|
|
|
|
std::unique_ptr<BigType<Size, Size>> ptr;
|
|
};
|
|
|
|
template <int Size>
|
|
double ContainerInfo(const btree_set<BigTypePtr<Size>>& b) {
|
|
const double bytes_used =
|
|
b.bytes_used() + b.size() * sizeof(BigType<Size, Size>);
|
|
const double bytes_per_value = bytes_used / b.size();
|
|
BtreeContainerInfoLog(b, bytes_used, bytes_per_value);
|
|
return bytes_per_value;
|
|
}
|
|
template <int Size>
|
|
double ContainerInfo(const btree_map<int, BigTypePtr<Size>>& b) {
|
|
const double bytes_used =
|
|
b.bytes_used() + b.size() * sizeof(BigType<Size, Size>);
|
|
const double bytes_per_value = bytes_used / b.size();
|
|
BtreeContainerInfoLog(b, bytes_used, bytes_per_value);
|
|
return bytes_per_value;
|
|
}
|
|
|
|
#define BIG_TYPE_PTR_BENCHMARKS(SIZE) \
|
|
using stl_set_size##SIZE##copies##SIZE##ptr = std::set<BigType<SIZE, SIZE>>; \
|
|
using stl_map_size##SIZE##copies##SIZE##ptr = \
|
|
std::map<int, BigType<SIZE, SIZE>>; \
|
|
using stl_unordered_set_size##SIZE##copies##SIZE##ptr = \
|
|
std::unordered_set<BigType<SIZE, SIZE>, \
|
|
absl::Hash<BigType<SIZE, SIZE>>>; \
|
|
using stl_unordered_map_size##SIZE##copies##SIZE##ptr = \
|
|
std::unordered_map<int, BigType<SIZE, SIZE>>; \
|
|
using flat_hash_set_size##SIZE##copies##SIZE##ptr = \
|
|
flat_hash_set<BigType<SIZE, SIZE>>; \
|
|
using flat_hash_map_size##SIZE##copies##SIZE##ptr = \
|
|
flat_hash_map<int, BigTypePtr<SIZE>>; \
|
|
using btree_256_set_size##SIZE##copies##SIZE##ptr = \
|
|
btree_set<BigTypePtr<SIZE>>; \
|
|
using btree_256_map_size##SIZE##copies##SIZE##ptr = \
|
|
btree_map<int, BigTypePtr<SIZE>>; \
|
|
MY_BENCHMARK3_STL(stl_set_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3_STL(stl_unordered_set_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3(flat_hash_set_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3(btree_256_set_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3_STL(stl_map_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3_STL(stl_unordered_map_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3(flat_hash_map_size##SIZE##copies##SIZE##ptr); \
|
|
MY_BENCHMARK3(btree_256_map_size##SIZE##copies##SIZE##ptr)
|
|
|
|
BIG_TYPE_PTR_BENCHMARKS(32);
|
|
|
|
} // namespace
|
|
} // namespace container_internal
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|