abseil-cpp/absl/hash/hash_benchmark.cc File Reference

#include <string>
#include <type_traits>
#include <typeindex>
#include <utility>
#include <vector>
#include "absl/base/attributes.h"
#include "absl/container/flat_hash_set.h"
#include "absl/hash/hash.h"
#include "absl/random/random.h"
#include "absl/strings/cord.h"
#include "absl/strings/cord_test_helpers.h"
#include "absl/strings/string_view.h"
#include "benchmark/benchmark.h"

Include dependency graph for abseil-cpp/absl/hash/hash_benchmark.cc:

Go to the source code of this file.

Classes
struct	FastUnorderedSet< T >
struct	PodRand< T >
struct	StringRand< N >
struct	TypeErasedAbslHash< T >
class	TypeErasedInterface
class	TypeErasedAbslHash< T >::Wrapper

Macros
#define	MAKE_BENCHMARK(hash, name, ...)
#define	MAKE_LATENCY_BENCHMARK(hash, name, ...)

Typedefs
template<typename T >
using	AbslHash = absl::Hash< T >

Functions
absl::Cord	FlatCord (size_t size)
template<typename T >
absl::flat_hash_set< T >	FlatHashSet (size_t count)
absl::Cord	FragmentedCord (size_t size)
	MAKE_BENCHMARK (AbslHash, Cord_Flat_0, absl::Cord())
	MAKE_BENCHMARK (AbslHash, Cord_Flat_10, FlatCord(10))
	MAKE_BENCHMARK (AbslHash, Cord_Flat_200, FlatCord(200))
	MAKE_BENCHMARK (AbslHash, Cord_Flat_30, FlatCord(30))
	MAKE_BENCHMARK (AbslHash, Cord_Flat_5000, FlatCord(5000))
	MAKE_BENCHMARK (AbslHash, Cord_Flat_90, FlatCord(90))
	MAKE_BENCHMARK (AbslHash, Cord_Fragmented_200, FragmentedCord(200))
	MAKE_BENCHMARK (AbslHash, Cord_Fragmented_5000, FragmentedCord(5000))
	MAKE_BENCHMARK (AbslHash, Double, 1.2)
	MAKE_BENCHMARK (AbslHash, DoubleZero, 0.0)
	MAKE_BENCHMARK (AbslHash, FastUnorderedSetDouble_1000, FastUnorderedSet< double >(1000))
	MAKE_BENCHMARK (AbslHash, FastUnorderedSetInt64_1000, FastUnorderedSet< int64_t >(1000))
	MAKE_BENCHMARK (AbslHash, FlatHashSetDouble_10, FlatHashSet< double >(10))
	MAKE_BENCHMARK (AbslHash, FlatHashSetDouble_100, FlatHashSet< double >(100))
	MAKE_BENCHMARK (AbslHash, FlatHashSetDouble_1000, FlatHashSet< double >(1000))
	MAKE_BENCHMARK (AbslHash, FlatHashSetInt64_10, FlatHashSet< int64_t >(10))
	MAKE_BENCHMARK (AbslHash, FlatHashSetInt64_100, FlatHashSet< int64_t >(100))
	MAKE_BENCHMARK (AbslHash, FlatHashSetInt64_1000, FlatHashSet< int64_t >(1000))
	MAKE_BENCHMARK (AbslHash, Int32, int32_t{})
	MAKE_BENCHMARK (AbslHash, Int64, int64_t{})
	MAKE_BENCHMARK (AbslHash, PairInt32Int32, std::pair< int32_t, int32_t >{})
	MAKE_BENCHMARK (AbslHash, PairInt64Int64, std::pair< int64_t, int64_t >{})
	MAKE_BENCHMARK (AbslHash, PairStringString_0, std::make_pair(std::string(), std::string()))
	MAKE_BENCHMARK (AbslHash, PairStringString_10, std::make_pair(std::string(10, 'a'), std::string(10, 'b')))
	MAKE_BENCHMARK (AbslHash, PairStringString_200, std::make_pair(std::string(200, 'a'), std::string(200, 'b')))
	MAKE_BENCHMARK (AbslHash, PairStringString_30, std::make_pair(std::string(30, 'a'), std::string(30, 'b')))
	MAKE_BENCHMARK (AbslHash, PairStringString_5000, std::make_pair(std::string(5000, 'a'), std::string(5000, 'b')))
	MAKE_BENCHMARK (AbslHash, PairStringString_90, std::make_pair(std::string(90, 'a'), std::string(90, 'b')))
	MAKE_BENCHMARK (AbslHash, String_0, std::string())
	MAKE_BENCHMARK (AbslHash, String_10, std::string(10, 'a'))
	MAKE_BENCHMARK (AbslHash, String_200, std::string(200, 'a'))
	MAKE_BENCHMARK (AbslHash, String_30, std::string(30, 'a'))
	MAKE_BENCHMARK (AbslHash, String_5000, std::string(5000, 'a'))
	MAKE_BENCHMARK (AbslHash, String_90, std::string(90, 'a'))
	MAKE_BENCHMARK (AbslHash, TupleInt32BoolInt64, std::tuple< int32_t, bool, int64_t >{})
	MAKE_BENCHMARK (AbslHash, VectorDouble_10, Vector< double >(10))
	MAKE_BENCHMARK (AbslHash, VectorDouble_100, Vector< double >(100))
	MAKE_BENCHMARK (AbslHash, VectorDouble_1000, Vector< double >(1000))
	MAKE_BENCHMARK (AbslHash, VectorInt64_10, Vector< int64_t >(10))
	MAKE_BENCHMARK (AbslHash, VectorInt64_100, Vector< int64_t >(100))
	MAKE_BENCHMARK (AbslHash, VectorInt64_1000, Vector< int64_t >(1000))
	MAKE_BENCHMARK (TypeErasedAbslHash, FastUnorderedSetDouble_1000, FastUnorderedSet< double >(1000))
	MAKE_BENCHMARK (TypeErasedAbslHash, FastUnorderedSetInt64_1000, FastUnorderedSet< int64_t >(1000))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetDouble_10, FlatHashSet< double >(10))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetDouble_100, FlatHashSet< double >(100))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetDouble_1000, FlatHashSet< double >(1000))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetInt64_10, FlatHashSet< int64_t >(10))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetInt64_100, FlatHashSet< int64_t >(100))
	MAKE_BENCHMARK (TypeErasedAbslHash, FlatHashSetInt64_1000, FlatHashSet< int64_t >(1000))
	MAKE_BENCHMARK (TypeErasedAbslHash, Int32, int32_t{})
	MAKE_BENCHMARK (TypeErasedAbslHash, Int64, int64_t{})
	MAKE_BENCHMARK (TypeErasedAbslHash, PairInt32Int32, std::pair< int32_t, int32_t >{})
	MAKE_BENCHMARK (TypeErasedAbslHash, PairInt64Int64, std::pair< int64_t, int64_t >{})
	MAKE_BENCHMARK (TypeErasedAbslHash, String_0, std::string())
	MAKE_BENCHMARK (TypeErasedAbslHash, String_10, std::string(10, 'a'))
	MAKE_BENCHMARK (TypeErasedAbslHash, String_200, std::string(200, 'a'))
	MAKE_BENCHMARK (TypeErasedAbslHash, String_30, std::string(30, 'a'))
	MAKE_BENCHMARK (TypeErasedAbslHash, String_5000, std::string(5000, 'a'))
	MAKE_BENCHMARK (TypeErasedAbslHash, String_90, std::string(90, 'a'))
	MAKE_BENCHMARK (TypeErasedAbslHash, TupleInt32BoolInt64, std::tuple< int32_t, bool, int64_t >{})
	MAKE_BENCHMARK (TypeErasedAbslHash, VectorDouble_10, std::vector< double >(10, 1.1))
	MAKE_BENCHMARK (TypeErasedAbslHash, VectorDouble_100, std::vector< double >(100, 1.1))
	MAKE_BENCHMARK (TypeErasedAbslHash, VectorDouble_1000, std::vector< double >(1000, 1.1))
	MAKE_LATENCY_BENCHMARK (AbslHash, Int32, PodRand< int32_t >)
	MAKE_LATENCY_BENCHMARK (AbslHash, Int64, PodRand< int64_t >)
	MAKE_LATENCY_BENCHMARK (AbslHash, String257, StringRand< 257 >)
	MAKE_LATENCY_BENCHMARK (AbslHash, String33, StringRand< 33 >)
	MAKE_LATENCY_BENCHMARK (AbslHash, String65, StringRand< 65 >)
	MAKE_LATENCY_BENCHMARK (AbslHash, String9, StringRand< 9 >)
template<typename FuncType >
FuncType *	ODRUseFunction (FuncType *ptr)
template<typename T >
std::vector< T >	Vector (size_t count)

Macro Definition Documentation

MAKE_BENCHMARK

#define MAKE_BENCHMARK	(		hash,
			name,
			...
	)

Value:

  namespace {                                                    \
  void BM_##hash##_##name(benchmark::State& state) {             \
    RunBenchmark<hash>(state, __VA_ARGS__);                      \
  }                                                              \
  BENCHMARK(BM_##hash##_##name);                                 \
  }                                                              \
  size_t Codegen##hash##name(const decltype(__VA_ARGS__)& arg);  \
  size_t Codegen##hash##name(const decltype(__VA_ARGS__)& arg) { \
    return hash<decltype(__VA_ARGS__)>{}(arg);                   \
  }                                                              \
  bool absl_hash_test_odr_use##hash##name =                      \
      ODRUseFunction(&Codegen##hash##name);

Definition at line 151 of file abseil-cpp/absl/hash/hash_benchmark.cc.

MAKE_LATENCY_BENCHMARK

#define MAKE_LATENCY_BENCHMARK	(		hash,
			name,
			...
	)

Value:

  namespace {                                                \
  void BM_latency_##hash##_##name(benchmark::State& state) { \
    __VA_ARGS__ r;                                           \
    hash<decltype(r.Get(0))> h;                              \
    size_t i = 871401241;                                    \
    for (auto _ : state) {                                   \
      benchmark::DoNotOptimize(i = h(r.Get(i)));             \
    }                                                        \
  }                                                          \
  BENCHMARK(BM_latency_##hash##_##name);                     \
  }

Definition at line 305 of file abseil-cpp/absl/hash/hash_benchmark.cc.

Typedef Documentation

AbslHash

template<typename T >

using AbslHash = absl::Hash<T>

Definition at line 46 of file abseil-cpp/absl/hash/hash_benchmark.cc.

Function Documentation

FlatCord()

absl::Cord FlatCord

(

size_t

size

)

Definition at line 88 of file abseil-cpp/absl/hash/hash_benchmark.cc.

FlatHashSet()

template<typename T >

absl::flat_hash_set<T> FlatHashSet

(

size_t

count

)

Definition at line 141 of file abseil-cpp/absl/hash/hash_benchmark.cc.

FragmentedCord()

absl::Cord FragmentedCord

(

size_t

size

)

Definition at line 94 of file abseil-cpp/absl/hash/hash_benchmark.cc.

MAKE_BENCHMARK() [1/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_0	,
		absl::Cord()
	)

MAKE_BENCHMARK() [2/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_10	,
		FlatCord(10)
	)

MAKE_BENCHMARK() [3/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_200	,
		FlatCord(200)
	)

MAKE_BENCHMARK() [4/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_30	,
		FlatCord(30)
	)

MAKE_BENCHMARK() [5/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_5000	,
		FlatCord(5000)
	)

MAKE_BENCHMARK() [6/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_90	,
		FlatCord(90)
	)

MAKE_BENCHMARK() [7/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Fragmented_200	,
		FragmentedCord(200)
	)

MAKE_BENCHMARK() [8/63]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Fragmented_5000	,
		FragmentedCord(5000)
	)

MAKE_BENCHMARK() [9/63]

MAKE_BENCHMARK	(	AbslHash	,
		Double	,
		1.	2
	)

MAKE_BENCHMARK() [10/63]

MAKE_BENCHMARK	(	AbslHash	,
		DoubleZero	,
		0.	0
	)

MAKE_BENCHMARK() [11/63]

MAKE_BENCHMARK	(	AbslHash	,
		FastUnorderedSetDouble_1000	,
		FastUnorderedSet< double >	1000
	)

MAKE_BENCHMARK() [12/63]

MAKE_BENCHMARK	(	AbslHash	,
		FastUnorderedSetInt64_1000	,
		FastUnorderedSet< int64_t >	1000
	)

MAKE_BENCHMARK() [13/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetDouble_10	,
		FlatHashSet< double >	10
	)

MAKE_BENCHMARK() [14/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetDouble_100	,
		FlatHashSet< double >	100
	)

MAKE_BENCHMARK() [15/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetDouble_1000	,
		FlatHashSet< double >	1000
	)

MAKE_BENCHMARK() [16/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetInt64_10	,
		FlatHashSet< int64_t >	10
	)

MAKE_BENCHMARK() [17/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetInt64_100	,
		FlatHashSet< int64_t >	100
	)

MAKE_BENCHMARK() [18/63]

MAKE_BENCHMARK	(	AbslHash	,
		FlatHashSetInt64_1000	,
		FlatHashSet< int64_t >	1000
	)

MAKE_BENCHMARK() [19/63]

MAKE_BENCHMARK	(	AbslHash	,
		Int32	,
		int32_t{}
	)

MAKE_BENCHMARK() [20/63]

MAKE_BENCHMARK	(	AbslHash	,
		Int64	,
		int64_t{}
	)

MAKE_BENCHMARK() [21/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairInt32Int32	,
		std::pair< int32_t, int32_t >{}
	)

MAKE_BENCHMARK() [22/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairInt64Int64	,
		std::pair< int64_t, int64_t >{}
	)

MAKE_BENCHMARK() [23/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_0	,
		std::make_pair(std::string(), std::string())
	)

MAKE_BENCHMARK() [24/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_10	,
		std::make_pair(std::string(10, 'a'), std::string(10, 'b'))
	)

MAKE_BENCHMARK() [25/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_200	,
		std::make_pair(std::string(200, 'a'), std::string(200, 'b'))
	)

MAKE_BENCHMARK() [26/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_30	,
		std::make_pair(std::string(30, 'a'), std::string(30, 'b'))
	)

MAKE_BENCHMARK() [27/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_5000	,
		std::make_pair(std::string(5000, 'a'), std::string(5000, 'b'))
	)

MAKE_BENCHMARK() [28/63]

MAKE_BENCHMARK	(	AbslHash	,
		PairStringString_90	,
		std::make_pair(std::string(90, 'a'), std::string(90, 'b'))
	)

MAKE_BENCHMARK() [29/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_0	,
		std::string()
	)

MAKE_BENCHMARK() [30/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_10	,
		std::string(10, 'a')
	)

MAKE_BENCHMARK() [31/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_200	,
		std::string(200, 'a')
	)

MAKE_BENCHMARK() [32/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_30	,
		std::string(30, 'a')
	)

MAKE_BENCHMARK() [33/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_5000	,
		std::string(5000, 'a')
	)

MAKE_BENCHMARK() [34/63]

MAKE_BENCHMARK	(	AbslHash	,
		String_90	,
		std::string(90, 'a')
	)

MAKE_BENCHMARK() [35/63]

MAKE_BENCHMARK	(	AbslHash	,
		TupleInt32BoolInt64	,
		std::tuple< int32_t, bool, int64_t >{}
	)

MAKE_BENCHMARK() [36/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorDouble_10	,
		Vector< double >	10
	)

MAKE_BENCHMARK() [37/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorDouble_100	,
		Vector< double >	100
	)

MAKE_BENCHMARK() [38/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorDouble_1000	,
		Vector< double >	1000
	)

MAKE_BENCHMARK() [39/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorInt64_10	,
		Vector< int64_t >	10
	)

MAKE_BENCHMARK() [40/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorInt64_100	,
		Vector< int64_t >	100
	)

MAKE_BENCHMARK() [41/63]

MAKE_BENCHMARK	(	AbslHash	,
		VectorInt64_1000	,
		Vector< int64_t >	1000
	)

MAKE_BENCHMARK() [42/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FastUnorderedSetDouble_1000	,
		FastUnorderedSet< double >	1000
	)

MAKE_BENCHMARK() [43/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FastUnorderedSetInt64_1000	,
		FastUnorderedSet< int64_t >	1000
	)

MAKE_BENCHMARK() [44/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetDouble_10	,
		FlatHashSet< double >	10
	)

MAKE_BENCHMARK() [45/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetDouble_100	,
		FlatHashSet< double >	100
	)

MAKE_BENCHMARK() [46/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetDouble_1000	,
		FlatHashSet< double >	1000
	)

MAKE_BENCHMARK() [47/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetInt64_10	,
		FlatHashSet< int64_t >	10
	)

MAKE_BENCHMARK() [48/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetInt64_100	,
		FlatHashSet< int64_t >	100
	)

MAKE_BENCHMARK() [49/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		FlatHashSetInt64_1000	,
		FlatHashSet< int64_t >	1000
	)

MAKE_BENCHMARK() [50/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		Int32	,
		int32_t{}
	)

MAKE_BENCHMARK() [51/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		Int64	,
		int64_t{}
	)

MAKE_BENCHMARK() [52/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		PairInt32Int32	,
		std::pair< int32_t, int32_t >{}
	)

MAKE_BENCHMARK() [53/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		PairInt64Int64	,
		std::pair< int64_t, int64_t >{}
	)

MAKE_BENCHMARK() [54/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_0	,
		std::string()
	)

MAKE_BENCHMARK() [55/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_10	,
		std::string(10, 'a')
	)

MAKE_BENCHMARK() [56/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_200	,
		std::string(200, 'a')
	)

MAKE_BENCHMARK() [57/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_30	,
		std::string(30, 'a')
	)

MAKE_BENCHMARK() [58/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_5000	,
		std::string(5000, 'a')
	)

MAKE_BENCHMARK() [59/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		String_90	,
		std::string(90, 'a')
	)

MAKE_BENCHMARK() [60/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		TupleInt32BoolInt64	,
		std::tuple< int32_t, bool, int64_t >{}
	)

MAKE_BENCHMARK() [61/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		VectorDouble_10	,
		std::vector< double >	10, 1.1
	)

MAKE_BENCHMARK() [62/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		VectorDouble_100	,
		std::vector< double >	100, 1.1
	)

MAKE_BENCHMARK() [63/63]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		VectorDouble_1000	,
		std::vector< double >	1000, 1.1
	)

MAKE_LATENCY_BENCHMARK() [1/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		Int32	,
		PodRand< int32_t >
	)

MAKE_LATENCY_BENCHMARK() [2/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		Int64	,
		PodRand< int64_t >
	)

MAKE_LATENCY_BENCHMARK() [3/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		String257	,
		StringRand< 257 >
	)

MAKE_LATENCY_BENCHMARK() [4/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		String33	,
		StringRand< 33 >
	)

MAKE_LATENCY_BENCHMARK() [5/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		String65	,
		StringRand< 65 >
	)

MAKE_LATENCY_BENCHMARK() [6/6]

MAKE_LATENCY_BENCHMARK	(	AbslHash	,
		String9	,
		StringRand< 9 >
	)

ODRUseFunction()

template<typename FuncType >

FuncType* ODRUseFunction ( FuncType *  ptr )

inline

Definition at line 83 of file abseil-cpp/absl/hash/hash_benchmark.cc.

Vector()

template<typename T >

std::vector<T> Vector

(

size_t

count

)

Definition at line 112 of file abseil-cpp/absl/hash/hash_benchmark.cc.