llvm-project

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
#include <cstdint>
10
#include <functional>
11
#include <memory>
12
#include <string>
13

14
#include "CartesianBenchmarks.h"
15
#include "benchmark/benchmark.h"
16
#include "test_macros.h"
17

18
namespace {
19

20
enum class FunctionType {
21
  Null,
22
  FunctionPointer,
23
  MemberFunctionPointer,
24
  MemberPointer,
25
  SmallTrivialFunctor,
26
  SmallNonTrivialFunctor,
27
  LargeTrivialFunctor,
28
  LargeNonTrivialFunctor
29
};
30

31
struct AllFunctionTypes : EnumValuesAsTuple<AllFunctionTypes, FunctionType, 8> {
32
  static constexpr const char* Names[] = {
33
      "Null",
34
      "FuncPtr",
35
      "MemFuncPtr",
36
      "MemPtr",
37
      "SmallTrivialFunctor",
38
      "SmallNonTrivialFunctor",
39
      "LargeTrivialFunctor",
40
      "LargeNonTrivialFunctor"};
41
};
42

43
enum class Opacity { kOpaque, kTransparent };
44

45
struct AllOpacity : EnumValuesAsTuple<AllOpacity, Opacity, 2> {
46
  static constexpr const char* Names[] = {"Opaque", "Transparent"};
47
};
48

49
struct S {
50
  int function() const { return 0; }
51
  int field = 0;
52
};
53

54
int FunctionWithS(const S*) { return 0; }
55

56
struct SmallTrivialFunctor {
57
  int operator()(const S*) const { return 0; }
58
};
59
struct SmallNonTrivialFunctor {
60
  SmallNonTrivialFunctor() {}
61
  SmallNonTrivialFunctor(const SmallNonTrivialFunctor&) {}
62
  ~SmallNonTrivialFunctor() {}
63
  int operator()(const S*) const { return 0; }
64
};
65
struct LargeTrivialFunctor {
66
  LargeTrivialFunctor() {
67
    // Do not spend time initializing the padding.
68
  }
69
  int padding[16];
70
  int operator()(const S*) const { return 0; }
71
};
72
struct LargeNonTrivialFunctor {
73
  int padding[16];
74
  LargeNonTrivialFunctor() {
75
    // Do not spend time initializing the padding.
76
  }
77
  LargeNonTrivialFunctor(const LargeNonTrivialFunctor&) {}
78
  ~LargeNonTrivialFunctor() {}
79
  int operator()(const S*) const { return 0; }
80
};
81

82
using Function = std::function<int(const S*)>;
83

84
TEST_ALWAYS_INLINE
85
inline Function MakeFunction(FunctionType type, bool opaque = false) {
86
  switch (type) {
87
  case FunctionType::Null:
88
    return nullptr;
89
  case FunctionType::FunctionPointer:
90
    return maybeOpaque(FunctionWithS, opaque);
91
  case FunctionType::MemberFunctionPointer:
92
    return maybeOpaque(&S::function, opaque);
93
  case FunctionType::MemberPointer:
94
    return maybeOpaque(&S::field, opaque);
95
  case FunctionType::SmallTrivialFunctor:
96
    return maybeOpaque(SmallTrivialFunctor{}, opaque);
97
  case FunctionType::SmallNonTrivialFunctor:
98
    return maybeOpaque(SmallNonTrivialFunctor{}, opaque);
99
  case FunctionType::LargeTrivialFunctor:
100
    return maybeOpaque(LargeTrivialFunctor{}, opaque);
101
  case FunctionType::LargeNonTrivialFunctor:
102
    return maybeOpaque(LargeNonTrivialFunctor{}, opaque);
103
  }
104
}
105

106
template <class Opacity, class FunctionType>
107
struct ConstructAndDestroy {
108
  static void run(benchmark::State& state) {
109
    for (auto _ : state) {
110
      if (Opacity() == ::Opacity::kOpaque) {
111
        benchmark::DoNotOptimize(MakeFunction(FunctionType(), true));
112
      } else {
113
        MakeFunction(FunctionType());
114
      }
115
    }
116
  }
117

118
  static std::string name() { return "BM_ConstructAndDestroy" + FunctionType::name() + Opacity::name(); }
119
};
120

121
template <class FunctionType>
122
struct Copy {
123
  static void run(benchmark::State& state) {
124
    auto value = MakeFunction(FunctionType());
125
    for (auto _ : state) {
126
      benchmark::DoNotOptimize(value);
127
      auto copy = value; // NOLINT
128
      benchmark::DoNotOptimize(copy);
129
    }
130
  }
131

132
  static std::string name() { return "BM_Copy" + FunctionType::name(); }
133
};
134

135
template <class FunctionType>
136
struct Move {
137
  static void run(benchmark::State& state) {
138
    Function values[2] = {MakeFunction(FunctionType())};
139
    int i              = 0;
140
    for (auto _ : state) {
141
      benchmark::DoNotOptimize(values);
142
      benchmark::DoNotOptimize(values[i ^ 1] = std::move(values[i]));
143
      i ^= 1;
144
    }
145
  }
146

147
  static std::string name() { return "BM_Move" + FunctionType::name(); }
148
};
149

150
template <class Function1, class Function2>
151
struct Swap {
152
  static void run(benchmark::State& state) {
153
    Function values[2] = {MakeFunction(Function1()), MakeFunction(Function2())};
154
    for (auto _ : state) {
155
      benchmark::DoNotOptimize(values);
156
      values[0].swap(values[1]);
157
    }
158
  }
159

160
  static bool skip() { return Function1() > Function2(); }
161

162
  static std::string name() { return "BM_Swap" + Function1::name() + Function2::name(); }
163
};
164

165
template <class FunctionType>
166
struct OperatorBool {
167
  static void run(benchmark::State& state) {
168
    auto f = MakeFunction(FunctionType());
169
    for (auto _ : state) {
170
      benchmark::DoNotOptimize(f);
171
      benchmark::DoNotOptimize(static_cast<bool>(f));
172
    }
173
  }
174

175
  static std::string name() { return "BM_OperatorBool" + FunctionType::name(); }
176
};
177

178
template <class FunctionType>
179
struct Invoke {
180
  static void run(benchmark::State& state) {
181
    S s;
182
    const auto value = MakeFunction(FunctionType());
183
    for (auto _ : state) {
184
      benchmark::DoNotOptimize(value);
185
      benchmark::DoNotOptimize(value(&s));
186
    }
187
  }
188

189
  static bool skip() { return FunctionType() == ::FunctionType::Null; }
190

191
  static std::string name() { return "BM_Invoke" + FunctionType::name(); }
192
};
193

194
template <class FunctionType>
195
struct InvokeInlined {
196
  static void run(benchmark::State& state) {
197
    S s;
198
    for (auto _ : state) {
199
      MakeFunction(FunctionType())(&s);
200
    }
201
  }
202

203
  static bool skip() { return FunctionType() == ::FunctionType::Null; }
204

205
  static std::string name() { return "BM_InvokeInlined" + FunctionType::name(); }
206
};
207

208
} // namespace
209

210
int main(int argc, char** argv) {
211
  benchmark::Initialize(&argc, argv);
212
  if (benchmark::ReportUnrecognizedArguments(argc, argv))
213
    return 1;
214

215
  makeCartesianProductBenchmark<ConstructAndDestroy, AllOpacity, AllFunctionTypes>();
216
  makeCartesianProductBenchmark<Copy, AllFunctionTypes>();
217
  makeCartesianProductBenchmark<Move, AllFunctionTypes>();
218
  makeCartesianProductBenchmark<Swap, AllFunctionTypes, AllFunctionTypes>();
219
  makeCartesianProductBenchmark<OperatorBool, AllFunctionTypes>();
220
  makeCartesianProductBenchmark<Invoke, AllFunctionTypes>();
221
  makeCartesianProductBenchmark<InvokeInlined, AllFunctionTypes>();
222
  benchmark::RunSpecifiedBenchmarks();
223
}
224