proxygen: proxygen/folly/folly/test/ConstexprMathBenchmark.cpp File Reference

#include <folly/Benchmark.h>
#include <folly/ConstexprMath.h>
#include <glog/logging.h>
#include <limits>
#include <type_traits>

Go to the source code of this file.

Macros
#define	GENERATE_BENCHMARKS_FOR_TYPE(ValueT)

Functions
template<typename ValueT >
constexpr ValueT	UBSafeAdd (ValueT a, ValueT b)

template<typename ValueT >
constexpr ValueT	UBSafeSub (ValueT a, ValueT b)

template<typename ValueT , typename Op >
void	Run (size_t iterations, ValueT kMin, ValueT kMax, Op &&op)

template<typename ValueT >
void	Add (size_t iterations, ValueT kMin, ValueT kMax)

template<typename ValueT >
void	NoOverflowAdd (size_t iterations, ValueT kMin, ValueT kMax)

template<typename ValueT >
void	Sub (size_t iterations, ValueT kMin, ValueT kMax)

template<typename ValueT >
void	NoOverflowSub (size_t iterations, ValueT kMin, ValueT kMax)

	BENCHMARK_NAMED_PARAM (Add, int8_t, std::numeric_limits< int8_t >::min(), std::numeric_limits< int8_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, uint8_t, std::numeric_limits< uint8_t >::min(), std::numeric_limits< uint8_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, int16_t, std::numeric_limits< int16_t >::min(), std::numeric_limits< int16_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, uint16_t, std::numeric_limits< uint16_t >::min(), std::numeric_limits< uint16_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, int32_t, std::numeric_limits< int32_t >::min(), std::numeric_limits< int32_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, uint32_t, std::numeric_limits< uint32_t >::min(), std::numeric_limits< uint32_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, int64_t, std::numeric_limits< int64_t >::min(), std::numeric_limits< int64_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

	BENCHMARK_NAMED_PARAM (Add, uint64_t, std::numeric_limits< uint64_t >::min(), std::numeric_limits< uint64_t >::max()) BENCHMARK_RELATIVE_NAMED_PARAM(NoOverflowAdd

Variables
	int8_t

	uint8_t

	int16_t

	uint16_t

	int32_t

	uint32_t

	int64_t

	uint64_t

char **	argv

	return

Macro Definition Documentation

#define GENERATE_BENCHMARKS_FOR_TYPE ( ValueT )

Value:

BENCHMARK_NAMED_PARAM(                     \
      Add,                                   \
      ValueT,                                \
      std::numeric_limits<ValueT>::min(),    \
      std::numeric_limits<ValueT>::max())    \
  BENCHMARK_RELATIVE_NAMED_PARAM(            \
      NoOverflowAdd,                         \
      ValueT,                                \
      std::numeric_limits<ValueT>::min(),    \
      std::numeric_limits<ValueT>::max())    \
  BENCHMARK_NAMED_PARAM(                     \
      Sub,                                   \
      ValueT,                                \
      std::numeric_limits<ValueT>::min(),    \
      std::numeric_limits<ValueT>::max())    \
  BENCHMARK_RELATIVE_NAMED_PARAM(            \
      NoOverflowSub,                         \
      ValueT,                                \
      std::numeric_limits<ValueT>::min(),    \
      std::numeric_limits<ValueT>::max())

Definition at line 154 of file ConstexprMathBenchmark.cpp.

Function Documentation

template<typename ValueT >

void Add	(	size_t	iterations,
		ValueT	kMin,
		ValueT	kMax
	)

Definition at line 127 of file ConstexprMathBenchmark.cpp.

References a, b, and UBSafeAdd().

                                                       {
   Run<ValueT>(iterations, kMin, kMax, [](ValueT a, ValueT b) {
     return UBSafeAdd(a, b);
   });
 }

BENCHMARK_NAMED_PARAM	(	Add	,
		int8_t	,
		std::numeric_limits< int8_t >	::min(),
		std::numeric_limits< int8_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		uint8_t	,
		std::numeric_limits< uint8_t >	::min(),
		std::numeric_limits< uint8_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		int16_t	,
		std::numeric_limits< int16_t >	::min(),
		std::numeric_limits< int16_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		uint16_t	,
		std::numeric_limits< uint16_t >	::min(),
		std::numeric_limits< uint16_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		int32_t	,
		std::numeric_limits< int32_t >	::min(),
		std::numeric_limits< int32_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		uint32_t	,
		std::numeric_limits< uint32_t >	::min(),
		std::numeric_limits< uint32_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		int64_t	,
		std::numeric_limits< int64_t >	::min(),
		std::numeric_limits< int64_t >	::max()
	)

BENCHMARK_NAMED_PARAM	(	Add	,
		uint64_t	,
		std::numeric_limits< uint64_t >	::min(),
		std::numeric_limits< uint64_t >	::max()
	)

template<typename ValueT >

void NoOverflowAdd	(	size_t	iterations,
		ValueT	kMin,
		ValueT	kMax
	)

Definition at line 134 of file ConstexprMathBenchmark.cpp.

References a, b, and folly::constexpr_add_overflow_clamped().

                                                                 {
   Run<ValueT>(iterations, kMin, kMax, [](ValueT a, ValueT b) {
     return folly::constexpr_add_overflow_clamped(a, b);
   });
 }

template<typename ValueT >

void NoOverflowSub	(	size_t	iterations,
		ValueT	kMin,
		ValueT	kMax
	)

Definition at line 148 of file ConstexprMathBenchmark.cpp.

References a, b, and folly::constexpr_sub_overflow_clamped().

                                                                 {
   Run<ValueT>(iterations, kMin, kMax, [](ValueT a, ValueT b) {
     return folly::constexpr_sub_overflow_clamped(a, b);
   });
 }

template<typename ValueT , typename Op >

void Run	(	size_t	iterations,
		ValueT	kMin,
		ValueT	kMax,
		Op &&	op
	)

Definition at line 38 of file ConstexprMathBenchmark.cpp.

References a, b, c, folly::doNotOptimizeAway(), folly::makeUnpredictable(), and folly::chrono::round().

Referenced by testing::internal::CheckedDowncastToActualType(), testing::TestCase::ClearTestCaseResult(), testing::TestEventListeners::default_xml_generator(), testing::Test::HasFailure(), testing::TestInfo::increment_death_test_count(), testing::internal::TransformTupleValuesHelper< Tuple, Func, OutIter >::IterateOverTuple< Tup, 0 >::operator()(), and testing::internal::TransformTupleValues().

                                                                {
   auto kMid = (kMin + kMax) / 2;
 
   for (size_t round = 0; round < iterations; round++) {
     for (ValueT a = kMin; a < kMin + 100; a++) {
       for (ValueT b = kMin; b < kMin + 100; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMin; a < kMin + 100; a++) {
       for (ValueT b = kMid - 50; b < kMid + 50; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMin; a < kMin + 100; a++) {
       for (ValueT b = kMax - 100; b < kMax; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMid - 50; a < kMid + 50; a++) {
       for (ValueT b = kMin; b < kMin + 100; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMid - 50; a < kMid + 50; a++) {
       for (ValueT b = kMid - 50; b < kMid + 50; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMid - 50; a < kMid + 50; a++) {
       for (ValueT b = kMax - 100; b < kMax; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMax - 100; a < kMax; a++) {
       for (ValueT b = kMin; b < kMin + 100; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMax - 100; a < kMax; a++) {
       for (ValueT b = kMid - 50; b < kMid + 50; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
     for (ValueT a = kMax - 100; a < kMax; a++) {
       for (ValueT b = kMax - 100; b < kMax; b++) {
         auto a1 = a, b1 = b;
         folly::makeUnpredictable(a1);
         folly::makeUnpredictable(b1);
         ValueT c = op(a1, b1);
         folly::doNotOptimizeAway(c);
       }
     }
   }
 }

template<typename ValueT >

void Sub	(	size_t	iterations,
		ValueT	kMin,
		ValueT	kMax
	)

Definition at line 141 of file ConstexprMathBenchmark.cpp.

References a, b, and UBSafeSub().

Referenced by folly::gen::sub().

                                                       {
   Run<ValueT>(iterations, kMin, kMax, [](ValueT a, ValueT b) {
     return UBSafeSub(a, b);
   });
 }

template<typename ValueT >

constexpr ValueT UBSafeAdd	(	ValueT	a,
		ValueT	b
	)

Definition at line 24 of file ConstexprMathBenchmark.cpp.

References a, and type.

Referenced by Add().

                                                {
   using UnsignedT = typename std::make_unsigned<ValueT>::type;
   return static_cast<ValueT>(
       static_cast<UnsignedT>(a) + static_cast<UnsignedT>(b));
 }

template<typename ValueT >

constexpr ValueT UBSafeSub	(	ValueT	a,
		ValueT	b
	)

Definition at line 31 of file ConstexprMathBenchmark.cpp.

References a, and type.

Referenced by Sub().

                                                {
   using UnsignedT = typename std::make_unsigned<ValueT>::type;
   return static_cast<ValueT>(
       static_cast<UnsignedT>(a) - static_cast<UnsignedT>(b));
 }