1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
//
// Copyright 2020 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/flags/flag.h"
#include "absl/time/time.h"
#include "absl/types/optional.h"
#include "benchmark/benchmark.h"
namespace {
using String = std::string;
using VectorOfStrings = std::vector<std::string>;
using AbslDuration = absl::Duration;
// We do not want to take over marshalling for the types absl::optional<int>,
// absl::optional<std::string> which we do not own. Instead we introduce unique
// "aliases" to these types, which we do.
using AbslOptionalInt = absl::optional<int>;
struct OptionalInt : AbslOptionalInt {
using AbslOptionalInt::AbslOptionalInt;
};
// Next two functions represent Abseil Flags marshalling for OptionalInt.
bool AbslParseFlag(absl::string_view src, OptionalInt* flag,
std::string* error) {
int val;
if (src.empty())
flag->reset();
else if (!absl::ParseFlag(src, &val, error))
return false;
*flag = val;
return true;
}
std::string AbslUnparseFlag(const OptionalInt& flag) {
return !flag ? "" : absl::UnparseFlag(*flag);
}
using AbslOptionalString = absl::optional<std::string>;
struct OptionalString : AbslOptionalString {
using AbslOptionalString::AbslOptionalString;
};
// Next two functions represent Abseil Flags marshalling for OptionalString.
bool AbslParseFlag(absl::string_view src, OptionalString* flag,
std::string* error) {
std::string val;
if (src.empty())
flag->reset();
else if (!absl::ParseFlag(src, &val, error))
return false;
*flag = val;
return true;
}
std::string AbslUnparseFlag(const OptionalString& flag) {
return !flag ? "" : absl::UnparseFlag(*flag);
}
struct UDT {
UDT() = default;
UDT(const UDT&) {}
UDT& operator=(const UDT&) { return *this; }
};
// Next two functions represent Abseil Flags marshalling for UDT.
bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
std::string AbslUnparseFlag(const UDT&) { return ""; }
} // namespace
#define BENCHMARKED_TYPES(A) \
A(bool) \
A(int16_t) \
A(uint16_t) \
A(int32_t) \
A(uint32_t) \
A(int64_t) \
A(uint64_t) \
A(double) \
A(float) \
A(String) \
A(VectorOfStrings) \
A(OptionalInt) \
A(OptionalString) \
A(AbslDuration) \
A(UDT)
#define FLAG_DEF(T) ABSL_FLAG(T, T##_flag, {}, "");
BENCHMARKED_TYPES(FLAG_DEF)
namespace {
#define BM_GetFlag(T) \
void BM_GetFlag_##T(benchmark::State& state) { \
for (auto _ : state) { \
benchmark::DoNotOptimize(absl::GetFlag(FLAGS_##T##_flag)); \
} \
} \
BENCHMARK(BM_GetFlag_##T);
BENCHMARKED_TYPES(BM_GetFlag)
} // namespace
|
