]>
Commit | Line | Data |
---|---|---|
1e59de90 TL |
1 | // Copyright The OpenTelemetry Authors |
2 | // SPDX-License-Identifier: Apache-2.0 | |
3 | ||
4 | #ifdef _WIN32 | |
5 | ||
6 | # include <benchmark/benchmark.h> | |
7 | # include <gtest/gtest.h> | |
8 | # include <map> | |
9 | # include <string> | |
10 | # include <unordered_map> | |
11 | ||
12 | # include "opentelemetry/exporters/etw/etw_tracer_exporter.h" | |
13 | # include "opentelemetry/sdk/trace/simple_processor.h" | |
14 | ||
15 | using namespace OPENTELEMETRY_NAMESPACE; | |
16 | ||
17 | using namespace opentelemetry::exporter::etw; | |
18 | ||
19 | namespace | |
20 | { | |
21 | static constexpr const char *providerName = "OpenTelemetry-ETW-StressTest"; | |
22 | ||
23 | static exporter::etw::TelemetryProviderOptions providerOptions = { | |
24 | {"enableTraceId", false}, | |
25 | {"enableSpanId", false}, | |
26 | {"enableActivityId", false}, | |
27 | {"enableRelatedActivityId", false}, | |
28 | {"enableAutoParent", false}}; | |
29 | ||
30 | class ETWProviderStressTest | |
31 | { | |
32 | exporter::etw::TracerProvider provider_; | |
33 | std::string mode_; | |
34 | nostd::shared_ptr<trace::Tracer> tracer_; | |
35 | nostd::shared_ptr<trace::Span> span_; | |
36 | ||
37 | public: | |
38 | /** | |
39 | * @brief Construct ETW Provider stress test object | |
40 | * @param mode Operational mode: "TLD" or "MsgPack" | |
41 | */ | |
42 | ETWProviderStressTest(std::string mode = "TLD") : mode_(mode), provider_(providerOptions) {} | |
43 | ||
44 | /** | |
45 | * @brief Initializer tracer and start a Span | |
46 | */ | |
47 | void Initialize() | |
48 | { | |
49 | tracer_ = provider_.GetTracer(providerName, mode_); | |
50 | span_ = tracer_->StartSpan("Span"); | |
51 | } | |
52 | ||
53 | /** | |
54 | * @brief Obtain the tracer | |
55 | */ | |
56 | nostd::shared_ptr<trace::Tracer> GetTracer() { return tracer_; } | |
57 | ||
58 | /** | |
59 | * @brief Add event using Properties container | |
60 | */ | |
61 | bool AddProperties() | |
62 | { | |
63 | std::string eventName = "MyEvent"; | |
64 | Properties event = {{"uint32Key", (uint32_t)1234}, | |
65 | {"uint64Key", (uint64_t)1234567890}, | |
66 | {"strKey", "someValue"}}; | |
67 | span_->AddEvent(eventName, event); | |
68 | return true; | |
69 | } | |
70 | ||
71 | /** | |
72 | * @brief Add event using static preallocated "reusable" Properties container. | |
73 | * This approach works well for single-threaded flows, but may not be safe in | |
74 | * some multithreaded scenarios in case if reusable `Properties` get concurrently | |
75 | * modified by different threads (writes to Properties are not thread-safe). | |
76 | */ | |
77 | bool AddPropertiesStatic() | |
78 | { | |
79 | std::string eventName = "MyEvent"; | |
80 | static Properties event = {{"uint32Key", (uint32_t)1234}, | |
81 | {"uint64Key", (uint64_t)1234567890}, | |
82 | {"strKey", "someValue"}}; | |
83 | span_->AddEvent(eventName, event); | |
84 | return true; | |
85 | } | |
86 | ||
87 | /** | |
88 | * @brief Add event using initializer list | |
89 | */ | |
90 | bool AddInitList() | |
91 | { | |
92 | std::string eventName = "MyEvent"; | |
93 | span_->AddEvent(eventName, {{"uint32Key", (uint32_t)1234}, | |
94 | {"uint64Key", (uint64_t)1234567890}, | |
95 | {"strKey", "someValue"}}); | |
96 | return true; | |
97 | } | |
98 | ||
99 | /** | |
100 | * @brief Add event using unordered_map | |
101 | */ | |
102 | bool AddMap() | |
103 | { | |
104 | std::string eventName = "MyEvent"; | |
105 | std::unordered_map<const char *, common::AttributeValue> m = { | |
106 | {"uint32Key", (uint32_t)1234}, | |
107 | {"uint64Key", (uint64_t)1234567890}, | |
108 | {"strKey", "someValue"}}; | |
109 | span_->AddEvent(eventName, m); | |
110 | return true; | |
111 | } | |
112 | ||
113 | /** | |
114 | * @brief End Span and close tracer. | |
115 | */ | |
116 | void Teardown() | |
117 | { | |
118 | span_->End(); | |
119 | tracer_->CloseWithMicroseconds(0); | |
120 | } | |
121 | }; | |
122 | ||
123 | ETWProviderStressTest provider; | |
124 | ||
125 | /** | |
126 | * @brief Create Properties and AddEvent(Properties) to Tracer | |
127 | * @param state Benchmark state. | |
128 | */ | |
129 | void BM_AddPropertiesToTracer(benchmark::State &state) | |
130 | { | |
131 | provider.Initialize(); | |
132 | while (state.KeepRunning()) | |
133 | { | |
134 | benchmark::DoNotOptimize(provider.AddProperties()); | |
135 | } | |
136 | provider.Teardown(); | |
137 | } | |
138 | BENCHMARK(BM_AddPropertiesToTracer); | |
139 | ||
140 | /** | |
141 | * @brief Create static Properties and AddEvent(Properties) to Tracer | |
142 | * @param state Benchmark state. | |
143 | */ | |
144 | void BM_AddPropertiesStaticToTracer(benchmark::State &state) | |
145 | { | |
146 | provider.Initialize(); | |
147 | while (state.KeepRunning()) | |
148 | { | |
149 | benchmark::DoNotOptimize(provider.AddPropertiesStatic()); | |
150 | } | |
151 | provider.Teardown(); | |
152 | } | |
153 | BENCHMARK(BM_AddPropertiesStaticToTracer); | |
154 | ||
155 | /** | |
156 | * @brief Create event via initializer list and AddEvent({...}) to Tracer | |
157 | * @param state Benchmark state. | |
158 | */ | |
159 | void BM_AddInitListToTracer(benchmark::State &state) | |
160 | { | |
161 | provider.Initialize(); | |
162 | while (state.KeepRunning()) | |
163 | { | |
164 | benchmark::DoNotOptimize(provider.AddInitList()); | |
165 | } | |
166 | provider.Teardown(); | |
167 | } | |
168 | BENCHMARK(BM_AddInitListToTracer); | |
169 | ||
170 | /** | |
171 | * @brief Create event as `std::map<std::string, common::AttributeValue>` | |
172 | * and AddEvent(event) to Tracer. | |
173 | * @param state Benchmark state. | |
174 | */ | |
175 | void BM_AddMapToTracer(benchmark::State &state) | |
176 | { | |
177 | provider.Initialize(); | |
178 | while (state.KeepRunning()) | |
179 | { | |
180 | benchmark::DoNotOptimize(provider.AddMap()); | |
181 | } | |
182 | provider.Teardown(); | |
183 | } | |
184 | BENCHMARK(BM_AddMapToTracer); | |
185 | ||
186 | } // namespace | |
187 | ||
188 | BENCHMARK_MAIN(); | |
189 | ||
190 | #endif |