bloaty/third_party/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/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 bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc:

Go to the source code of this file.

Classes
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)
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, 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, std::vector< double >(10, 1.1))
	MAKE_BENCHMARK (AbslHash, VectorDouble_100, std::vector< double >(100, 1.1))
	MAKE_BENCHMARK (AbslHash, VectorInt64_10, std::vector< int64_t >(10))
	MAKE_BENCHMARK (AbslHash, VectorInt64_100, std::vector< int64_t >(100))
	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_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)

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 112 of file bloaty/third_party/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 236 of file bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc.

Typedef Documentation

AbslHash

template<typename T >

using AbslHash = absl::Hash<T>

Definition at line 45 of file bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc.

Function Documentation

FlatCord()

absl::Cord FlatCord

(

size_t

size

)

Definition at line 87 of file bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc.

FragmentedCord()

absl::Cord FragmentedCord

(

size_t

size

)

Definition at line 93 of file bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc.

MAKE_BENCHMARK() [1/44]

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

MAKE_BENCHMARK() [2/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_10	,
		FlatCord(10)
	)

MAKE_BENCHMARK() [3/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_200	,
		FlatCord(200)
	)

MAKE_BENCHMARK() [4/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_30	,
		FlatCord(30)
	)

MAKE_BENCHMARK() [5/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_5000	,
		FlatCord(5000)
	)

MAKE_BENCHMARK() [6/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Flat_90	,
		FlatCord(90)
	)

MAKE_BENCHMARK() [7/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Fragmented_200	,
		FragmentedCord(200)
	)

MAKE_BENCHMARK() [8/44]

MAKE_BENCHMARK	(	AbslHash	,
		Cord_Fragmented_5000	,
		FragmentedCord(5000)
	)

MAKE_BENCHMARK() [9/44]

MAKE_BENCHMARK	(	AbslHash	,
		Double	,
		1.	2
	)

MAKE_BENCHMARK() [10/44]

MAKE_BENCHMARK	(	AbslHash	,
		DoubleZero	,
		0.	0
	)

MAKE_BENCHMARK() [11/44]

MAKE_BENCHMARK	(	AbslHash	,
		Int32	,
		int32_t{}
	)

MAKE_BENCHMARK() [12/44]

MAKE_BENCHMARK	(	AbslHash	,
		Int64	,
		int64_t{}
	)

MAKE_BENCHMARK() [13/44]

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

MAKE_BENCHMARK() [14/44]

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

MAKE_BENCHMARK() [15/44]

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

MAKE_BENCHMARK() [16/44]

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

MAKE_BENCHMARK() [17/44]

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

MAKE_BENCHMARK() [18/44]

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

MAKE_BENCHMARK() [19/44]

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

MAKE_BENCHMARK() [20/44]

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

MAKE_BENCHMARK() [21/44]

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

MAKE_BENCHMARK() [22/44]

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

MAKE_BENCHMARK() [23/44]

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

MAKE_BENCHMARK() [24/44]

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

MAKE_BENCHMARK() [25/44]

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

MAKE_BENCHMARK() [26/44]

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

MAKE_BENCHMARK() [27/44]

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

MAKE_BENCHMARK() [28/44]

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

MAKE_BENCHMARK() [29/44]

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

MAKE_BENCHMARK() [30/44]

MAKE_BENCHMARK	(	AbslHash	,
		VectorInt64_10	,
		std::vector< int64_t >	10
	)

MAKE_BENCHMARK() [31/44]

MAKE_BENCHMARK	(	AbslHash	,
		VectorInt64_100	,
		std::vector< int64_t >	100
	)

MAKE_BENCHMARK() [32/44]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		Int32	,
		int32_t{}
	)

MAKE_BENCHMARK() [33/44]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		Int64	,
		int64_t{}
	)

MAKE_BENCHMARK() [34/44]

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

MAKE_BENCHMARK() [35/44]

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

MAKE_BENCHMARK() [36/44]

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

MAKE_BENCHMARK() [37/44]

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

MAKE_BENCHMARK() [38/44]

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

MAKE_BENCHMARK() [39/44]

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

MAKE_BENCHMARK() [40/44]

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

MAKE_BENCHMARK() [41/44]

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

MAKE_BENCHMARK() [42/44]

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

MAKE_BENCHMARK() [43/44]

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

MAKE_BENCHMARK() [44/44]

MAKE_BENCHMARK	(	TypeErasedAbslHash	,
		VectorDouble_100	,
		std::vector< double >	100, 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 82 of file bloaty/third_party/abseil-cpp/absl/hash/hash_benchmark.cc.