Home | History | Annotate | Line # | Download | only in benchmarks 
      1 //===----------------------------------------------------------------------===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 
      9 
     10 #include <string>
     11 #include <tuple>
     12 #include <type_traits>
     13 #include <vector>
     14 
     15 #include "benchmark/benchmark.h"
     16 #include "test_macros.h"
     17 
     18 namespace internal {
     19 
     20 template <class D, class E, size_t I>
     21 struct EnumValue : std::integral_constant<E, static_cast<E>(I)> {
     22   static std::string name() { return std::string("_") + D::Names[I]; }
     23 };
     24 
     25 template <class D, class E, size_t ...Idxs>
     26 constexpr auto makeEnumValueTuple(std::index_sequence<Idxs...>) {
     27   return std::make_tuple(EnumValue<D, E, Idxs>{}...);
     28 }
     29 
     30 template <class B>
     31 static auto skip(const B& Bench, int) -> decltype(Bench.skip()) {
     32   return Bench.skip();
     33 }
     34 template <class B>
     35 static auto skip(const B& Bench, char) {
     36   return false;
     37 }
     38 
     39 template <class B, class Args, size_t... Is>
     40 void makeBenchmarkFromValuesImpl(const Args& A, std::index_sequence<Is...>) {
     41   for (auto& V : A) {
     42     B Bench{std::get<Is>(V)...};
     43     if (!internal::skip(Bench, 0)) {
     44       benchmark::RegisterBenchmark(Bench.name().c_str(),
     45                                    [=](benchmark::State& S) { Bench.run(S); });
     46     }
     47   }
     48 }
     49 
     50 template <class B, class... Args>
     51 void makeBenchmarkFromValues(const std::vector<std::tuple<Args...> >& A) {
     52   makeBenchmarkFromValuesImpl<B>(A, std::index_sequence_for<Args...>());
     53 }
     54 
     55 template <template <class...> class B, class Args, class... U>
     56 void makeBenchmarkImpl(const Args& A, std::tuple<U...> t) {
     57   makeBenchmarkFromValues<B<U...> >(A);
     58 }
     59 
     60 template <template <class...> class B, class Args, class... U,
     61           class... T, class... Tuples>
     62 void makeBenchmarkImpl(const Args& A, std::tuple<U...>, std::tuple<T...>,
     63                        Tuples... rest) {
     64   (internal::makeBenchmarkImpl<B>(A, std::tuple<U..., T>(), rest...), ...);
     65 }
     66 
     67 template <class R, class T>
     68 void allValueCombinations(R& Result, const T& Final) {
     69   return Result.push_back(Final);
     70 }
     71 
     72 template <class R, class T, class V, class... Vs>
     73 void allValueCombinations(R& Result, const T& Prev, const V& Value,
     74                           const Vs&... Values) {
     75   for (const auto& E : Value) {
     76     allValueCombinations(Result, std::tuple_cat(Prev, std::make_tuple(E)),
     77                          Values...);
     78   }
     79 }
     80 
     81 }  // namespace internal
     82 
     83 // CRTP class that enables using enum types as a dimension for
     84 // makeCartesianProductBenchmark below.
     85 // The type passed to `B` will be a std::integral_constant<E, e>, with the
     86 // additional static function `name()` that returns the stringified name of the
     87 // label.
     88 //
     89 // Eg:
     90 // enum class MyEnum { A, B };
     91 // struct AllMyEnum : EnumValuesAsTuple<AllMyEnum, MyEnum, 2> {
     92 //   static constexpr absl::string_view Names[] = {"A", "B"};
     93 // };
     94 template <class Derived, class EnumType, size_t NumLabels>
     95 using EnumValuesAsTuple =
     96     decltype(internal::makeEnumValueTuple<Derived, EnumType>(
     97         std::make_index_sequence<NumLabels>{}));
     98 
     99 // Instantiates B<T0, T1, ..., TN> where <Ti...> are the combinations in the
    100 // cartesian product of `Tuples...`, and pass (arg0, ..., argN) as constructor
    101 // arguments where `(argi...)` are the combination in the cartesian product of
    102 // the runtime values of `A...`.
    103 // B<T...> requires:
    104 //  - std::string name(args...): The name of the benchmark.
    105 //  - void run(benchmark::State&, args...): The body of the benchmark.
    106 // It can also optionally provide:
    107 //  - bool skip(args...): When `true`, skips the combination. Default is false.
    108 //
    109 // Returns int to facilitate registration. The return value is unspecified.
    110 template <template <class...> class B, class... Tuples, class... Args>
    111 int makeCartesianProductBenchmark(const Args&... A) {
    112   std::vector<std::tuple<typename Args::value_type...> > V;
    113   internal::allValueCombinations(V, std::tuple<>(), A...);
    114   internal::makeBenchmarkImpl<B>(V, std::tuple<>(), Tuples()...);
    115   return 0;
    116 }
    117 
    118 template <class B, class... Args>
    119 int makeCartesianProductBenchmark(const Args&... A) {
    120   std::vector<std::tuple<typename Args::value_type...> > V;
    121   internal::allValueCombinations(V, std::tuple<>(), A...);
    122   internal::makeBenchmarkFromValues<B>(V);
    123   return 0;
    124 }
    125 
    126 // When `opaque` is true, this function hides the runtime state of `value` from
    127 // the optimizer.
    128 // It returns `value`.
    129 template <class T>
    130 TEST_ALWAYS_INLINE inline T maybeOpaque(T value, bool opaque) {
    131   if (opaque) benchmark::DoNotOptimize(value);
    132   return value;
    133 }
    134