#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"

Include dependency graph for abseil-cpp/absl/container/btree_benchmark.cc:

Namespaces
	absl

	absl::container_internal

Macros
#define	BIG_TYPE_BENCHMARKS(SIZE, COPIES)

#define	BIG_TYPE_PTR_BENCHMARKS(SIZE)

#define	BTREE_TYPES(value)

#define	MY_BENCHMARK(type)

#define	MY_BENCHMARK2(type)

#define	MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(type)

#define	MY_BENCHMARK3(type)

#define	MY_BENCHMARK3_STL(type)

#define	MY_BENCHMARK4(type, func)

#define	STL_ORDERED_TYPES(value)

#define	STL_UNORDERED_TYPES(value)

#define	STL_UNORDERED_TYPES_CUSTOM_HASH(value, hash)

Macro Definition Documentation

◆ BIG_TYPE_BENCHMARKS

#define BIG_TYPE_BENCHMARKS	(	SIZE,
		COPIES
	)

Definition at line 611 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ BIG_TYPE_PTR_BENCHMARKS

#define BIG_TYPE_PTR_BENCHMARKS ( SIZE )

Value:

  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)

Definition at line 708 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ BTREE_TYPES

#define BTREE_TYPES ( value )

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>>>

Definition at line 492 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK

#define MY_BENCHMARK ( type )

Value:

MY_BENCHMARK2(set_##type); \

MY_BENCHMARK2(map_##type)

Definition at line 552 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK2

#define MY_BENCHMARK2 ( type )

Value:

MY_BENCHMARK2_SUPPORTS_MULTI_ONLY(type); \

MY_BENCHMARK3(flat_hash_##type)

Definition at line 538 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK2_SUPPORTS_MULTI_ONLY

#define MY_BENCHMARK2_SUPPORTS_MULTI_ONLY ( type )

Value:

  MY_BENCHMARK3_STL(stl_##type);                \
  MY_BENCHMARK3_STL(stl_unordered_##type);      \
  MY_BENCHMARK3(btree_256_##type)

Definition at line 533 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK3

#define MY_BENCHMARK3 ( type )

Value:

MY_BENCHMARK4(type, EraseIf); \

MY_BENCHMARK3_STL(type)

Definition at line 529 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK3_STL

#define MY_BENCHMARK3_STL ( type )

Value:

  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)

Definition at line 514 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ MY_BENCHMARK4

#define MY_BENCHMARK4	(	type,
		func
	)

Value:

void BM_##type##_##func(benchmark::State& state) { BM_##func<type>(state); } \

BENCHMARK(BM_##type##_##func)

Definition at line 510 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ STL_ORDERED_TYPES

#define STL_ORDERED_TYPES ( value )

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>

Definition at line 454 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ STL_UNORDERED_TYPES

#define STL_UNORDERED_TYPES ( value )

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>

Definition at line 467 of file abseil-cpp/absl/container/btree_benchmark.cc.

◆ STL_UNORDERED_TYPES_CUSTOM_HASH

#define STL_UNORDERED_TYPES_CUSTOM_HASH	(	value,
		hash
	)

Value:

  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>