mirror of
https://github.com/llvm-mirror/libcxx.git
synced 2025-10-21 23:30:38 +08:00
11b8a46498
Summary: Benchmarks for construct, copy, move, swap, destroy and invoke, with 8 different input states. For the cases that matter, it tests with and without allowing constant value propagation from construction into the operation tested. This also adds helper functions to generate the cartesian product of different configurations and generate benchmarks for all of them. Reviewers: EricWF Subscribers: christof, ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D53087 git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@344415 91177308-0d34-0410-b5e6-96231b3b80d8
93 lines
2.9 KiB
C++
93 lines
2.9 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
|
|
#include "benchmark/benchmark.h"
|
|
#include "test_macros.h"
|
|
|
|
namespace internal {
|
|
|
|
template <class D, class E, size_t I>
|
|
struct EnumValue : std::integral_constant<E, static_cast<E>(I)> {
|
|
static std::string name() { return std::string("_") + D::Names[I]; }
|
|
};
|
|
|
|
template <class D, class E, size_t ...Idxs>
|
|
constexpr auto makeEnumValueTuple(std::index_sequence<Idxs...>) {
|
|
return std::make_tuple(EnumValue<D, E, Idxs>{}...);
|
|
}
|
|
|
|
template <class T>
|
|
static auto skip(int) -> decltype(T::skip()) {
|
|
return T::skip();
|
|
}
|
|
template <class T>
|
|
static bool skip(char) {
|
|
return false;
|
|
}
|
|
|
|
template <template <class...> class B, class... U>
|
|
void makeBenchmarkImpl(std::tuple<U...> t) {
|
|
using T = B<U...>;
|
|
if (!internal::skip<T>(0))
|
|
benchmark::RegisterBenchmark(T::name().c_str(), T::run);
|
|
}
|
|
|
|
template <template <class...> class B, class... U, class... T, class... Tuples>
|
|
void makeBenchmarkImpl(std::tuple<U...>, std::tuple<T...>, Tuples... rest) {
|
|
(internal::makeBenchmarkImpl<B>(std::tuple<U..., T>(), rest...), ...);
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
// CRTP class that enables using enum types as a dimension for
|
|
// makeCartesianProductBenchmark below.
|
|
// The type passed to `B` will be a std::integral_constant<E, e>, with the
|
|
// additional static function `name()` that returns the stringified name of the
|
|
// label.
|
|
//
|
|
// Eg:
|
|
// enum class MyEnum { A, B };
|
|
// struct AllMyEnum : EnumValuesAsTuple<AllMyEnum, MyEnum, 2> {
|
|
// static constexpr absl::string_view Names[] = {"A", "B"};
|
|
// };
|
|
template <class Derived, class EnumType, size_t NumLabels>
|
|
using EnumValuesAsTuple =
|
|
decltype(internal::makeEnumValueTuple<Derived, EnumType>(
|
|
std::make_index_sequence<NumLabels>{}));
|
|
|
|
// Instantiates B<T0, T1, ..., TN> where <Ti...> are the combinations in the
|
|
// cartesian product of `Tuples...`
|
|
// B<T...> requires:
|
|
// - static std::string name(): The name of the benchmark.
|
|
// - static void run(benchmark::State&): The body of the benchmark.
|
|
// It can also optionally provide:
|
|
// - static bool skip(): When `true`, skips the combination. Default is false.
|
|
//
|
|
// Returns int to facilitate registration. The return value is unspecified.
|
|
template <template <class...> class B, class... Tuples>
|
|
int makeCartesianProductBenchmark() {
|
|
internal::makeBenchmarkImpl<B>(std::tuple<>(), Tuples()...);
|
|
return 0;
|
|
}
|
|
|
|
// When `opaque` is true, this function hides the runtime state of `value` from
|
|
// the optimizer.
|
|
// It returns `value`.
|
|
template <class T>
|
|
TEST_ALWAYS_INLINE inline T maybeOpaque(T value, bool opaque) {
|
|
if (opaque) benchmark::DoNotOptimize(value);
|
|
return value;
|
|
}
|
|
|