1 #include <queue>
2 #include <string>
3 #include <vector>
4
5 #include "../src/commandlineflags.h"
6 #include "../src/string_util.h"
7 #include "benchmark/benchmark.h"
8 #include "gmock/gmock.h"
9 #include "gtest/gtest.h"
10
11 namespace benchmark {
12
13 BM_DECLARE_bool(benchmark_enable_random_interleaving);
14 BM_DECLARE_string(benchmark_filter);
15 BM_DECLARE_int32(benchmark_repetitions);
16
17 namespace internal {
18 namespace {
19
20 class EventQueue : public std::queue<std::string> {
21 public:
Put(const std::string & event)22 void Put(const std::string& event) { push(event); }
23
Clear()24 void Clear() {
25 while (!empty()) {
26 pop();
27 }
28 }
29
Get()30 std::string Get() {
31 std::string event = front();
32 pop();
33 return event;
34 }
35 };
36
37 EventQueue* queue = new EventQueue();
38
39 class NullReporter : public BenchmarkReporter {
40 public:
ReportContext(const Context &)41 bool ReportContext(const Context& /*context*/) override { return true; }
ReportRuns(const std::vector<Run> &)42 void ReportRuns(const std::vector<Run>& /* report */) override {}
43 };
44
45 class BenchmarkTest : public testing::Test {
46 public:
SetupHook(int)47 static void SetupHook(int /* num_threads */) { queue->push("Setup"); }
48
TeardownHook(int)49 static void TeardownHook(int /* num_threads */) { queue->push("Teardown"); }
50
Execute(const std::string & pattern)51 void Execute(const std::string& pattern) {
52 queue->Clear();
53
54 BenchmarkReporter* reporter = new NullReporter;
55 FLAGS_benchmark_filter = pattern;
56 RunSpecifiedBenchmarks(reporter);
57 delete reporter;
58
59 queue->Put("DONE"); // End marker
60 }
61 };
62
BM_Match1(benchmark::State & state)63 void BM_Match1(benchmark::State& state) {
64 const int64_t arg = state.range(0);
65
66 for (auto _ : state) {
67 }
68 queue->Put(StrFormat("BM_Match1/%d", static_cast<int>(arg)));
69 }
70 BENCHMARK(BM_Match1)
71 ->Iterations(100)
72 ->Arg(1)
73 ->Arg(2)
74 ->Arg(3)
75 ->Range(10, 80)
76 ->Args({90})
77 ->Args({100});
78
TEST_F(BenchmarkTest,Match1)79 TEST_F(BenchmarkTest, Match1) {
80 Execute("BM_Match1");
81 ASSERT_EQ("BM_Match1/1", queue->Get());
82 ASSERT_EQ("BM_Match1/2", queue->Get());
83 ASSERT_EQ("BM_Match1/3", queue->Get());
84 ASSERT_EQ("BM_Match1/10", queue->Get());
85 ASSERT_EQ("BM_Match1/64", queue->Get());
86 ASSERT_EQ("BM_Match1/80", queue->Get());
87 ASSERT_EQ("BM_Match1/90", queue->Get());
88 ASSERT_EQ("BM_Match1/100", queue->Get());
89 ASSERT_EQ("DONE", queue->Get());
90 }
91
TEST_F(BenchmarkTest,Match1WithRepetition)92 TEST_F(BenchmarkTest, Match1WithRepetition) {
93 FLAGS_benchmark_repetitions = 2;
94
95 Execute("BM_Match1/(64|80)");
96 ASSERT_EQ("BM_Match1/64", queue->Get());
97 ASSERT_EQ("BM_Match1/64", queue->Get());
98 ASSERT_EQ("BM_Match1/80", queue->Get());
99 ASSERT_EQ("BM_Match1/80", queue->Get());
100 ASSERT_EQ("DONE", queue->Get());
101 }
102
TEST_F(BenchmarkTest,Match1WithRandomInterleaving)103 TEST_F(BenchmarkTest, Match1WithRandomInterleaving) {
104 FLAGS_benchmark_enable_random_interleaving = true;
105 FLAGS_benchmark_repetitions = 100;
106
107 std::map<std::string, int> element_count;
108 std::map<std::string, int> interleaving_count;
109 Execute("BM_Match1/(64|80)");
110 for (int i = 0; i < 100; ++i) {
111 std::vector<std::string> interleaving;
112 interleaving.push_back(queue->Get());
113 interleaving.push_back(queue->Get());
114 element_count[interleaving[0]]++;
115 element_count[interleaving[1]]++;
116 interleaving_count[StrFormat("%s,%s", interleaving[0].c_str(),
117 interleaving[1].c_str())]++;
118 }
119 EXPECT_EQ(element_count["BM_Match1/64"], 100) << "Unexpected repetitions.";
120 EXPECT_EQ(element_count["BM_Match1/80"], 100) << "Unexpected repetitions.";
121 EXPECT_GE(interleaving_count.size(), 2) << "Interleaving was not randomized.";
122 ASSERT_EQ("DONE", queue->Get());
123 }
124
125 } // namespace
126 } // namespace internal
127 } // namespace benchmark
128