1 // Copyright (C) 2020 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <benchmark/benchmark.h>
16
17 #include "perfetto/tracing.h"
18 #include "protos/perfetto/trace/test_event.pbzero.h"
19 #include "protos/perfetto/trace/trace.pbzero.h"
20 #include "protos/perfetto/trace/trace_packet.pbzero.h"
21 #include "protos/perfetto/trace/track_event/log_message.pbzero.h"
22
23 PERFETTO_DEFINE_CATEGORIES(perfetto::Category("benchmark"));
24 PERFETTO_TRACK_EVENT_STATIC_STORAGE();
25
26 namespace {
27
28 class BenchmarkDataSource : public perfetto::DataSource<BenchmarkDataSource> {
29 public:
OnSetup(const SetupArgs &)30 void OnSetup(const SetupArgs&) override {}
OnStart(const StartArgs &)31 void OnStart(const StartArgs&) override {}
OnStop(const StopArgs &)32 void OnStop(const StopArgs&) override {}
33 };
34
BM_TracingDataSourceDisabled(benchmark::State & state)35 static void BM_TracingDataSourceDisabled(benchmark::State& state) {
36 while (state.KeepRunning()) {
37 BenchmarkDataSource::Trace([&](BenchmarkDataSource::TraceContext) {});
38 benchmark::ClobberMemory();
39 }
40 }
41
StartTracing(const std::string & data_source_name)42 std::unique_ptr<perfetto::TracingSession> StartTracing(
43 const std::string& data_source_name) {
44 perfetto::TracingInitArgs args;
45 args.backends = perfetto::kInProcessBackend;
46 perfetto::Tracing::Initialize(args);
47
48 perfetto::DataSourceDescriptor dsd;
49 dsd.set_name("benchmark");
50 BenchmarkDataSource::Register(dsd);
51 perfetto::TrackEvent::Register();
52
53 perfetto::TraceConfig cfg;
54 cfg.add_buffers()->set_size_kb(1024);
55 auto* ds_cfg = cfg.add_data_sources()->mutable_config();
56 ds_cfg->set_name(data_source_name);
57 auto tracing_session =
58 perfetto::Tracing::NewTrace(perfetto::kInProcessBackend);
59 tracing_session->Setup(cfg);
60 tracing_session->StartBlocking();
61 return tracing_session;
62 }
63
BM_TracingDataSourceLambda(benchmark::State & state)64 static void BM_TracingDataSourceLambda(benchmark::State& state) {
65 auto tracing_session = StartTracing("benchmark");
66
67 while (state.KeepRunning()) {
68 BenchmarkDataSource::Trace([&](BenchmarkDataSource::TraceContext ctx) {
69 auto packet = ctx.NewTracePacket();
70 packet->set_timestamp(42);
71 packet->set_for_testing()->set_str("benchmark");
72 });
73 benchmark::ClobberMemory();
74 }
75
76 tracing_session->StopBlocking();
77 PERFETTO_CHECK(!tracing_session->ReadTraceBlocking().empty());
78 }
79
80 // Parses `trace` and returns the size of the first trace packet that contains
81 // `for_testing()`.
GetForTestingPacketSizeFromTrace(const std::vector<char> & trace)82 size_t GetForTestingPacketSizeFromTrace(const std::vector<char>& trace) {
83 size_t packet_size = 0;
84 perfetto::protos::pbzero::Trace::Decoder decoder(
85 reinterpret_cast<const uint8_t*>(trace.data()), trace.size());
86 for (auto packet = decoder.packet(); packet; packet++) {
87 perfetto::protos::pbzero::TracePacket::Decoder packet_decoder(*packet);
88
89 if (packet_decoder.has_for_testing()) {
90 packet_size = packet->size();
91 break;
92 }
93 }
94 return packet_size;
95 }
96
BM_TracingDataSourceLambdaDifferentPacketSize(benchmark::State & state)97 static void BM_TracingDataSourceLambdaDifferentPacketSize(
98 benchmark::State& state) {
99 auto tracing_session = StartTracing("benchmark");
100 // The number of string fields added in the nested submessage. This controls
101 // the size of the trace packet (reported by the "PacketSize" counter).
102 const size_t kNumFields = static_cast<size_t>(state.range(0));
103
104 for (auto _ : state) {
105 BenchmarkDataSource::Trace([&](BenchmarkDataSource::TraceContext ctx) {
106 auto packet = ctx.NewTracePacket();
107 auto* payload = packet->set_for_testing()->set_payload();
108 for (size_t i = 0; i < kNumFields; i++) {
109 payload->add_str("ABCDEFGH");
110 }
111 });
112 benchmark::ClobberMemory();
113 }
114
115 tracing_session->StopBlocking();
116
117 std::vector<char> trace = tracing_session->ReadTraceBlocking();
118 PERFETTO_CHECK(!trace.empty());
119 state.counters["PacketSize"] =
120 static_cast<double>(GetForTestingPacketSizeFromTrace(trace));
121 }
122
BM_TracingTrackEventDisabled(benchmark::State & state)123 static void BM_TracingTrackEventDisabled(benchmark::State& state) {
124 while (state.KeepRunning()) {
125 TRACE_EVENT_BEGIN("benchmark", "DisabledEvent");
126 benchmark::ClobberMemory();
127 }
128 }
129
BM_TracingTrackEventBasic(benchmark::State & state)130 static void BM_TracingTrackEventBasic(benchmark::State& state) {
131 auto tracing_session = StartTracing("track_event");
132
133 while (state.KeepRunning()) {
134 TRACE_EVENT_BEGIN("benchmark", "Event");
135 benchmark::ClobberMemory();
136 }
137
138 tracing_session->StopBlocking();
139 PERFETTO_CHECK(!tracing_session->ReadTraceBlocking().empty());
140 }
141
BM_TracingTrackEventDebugAnnotations(benchmark::State & state)142 static void BM_TracingTrackEventDebugAnnotations(benchmark::State& state) {
143 auto tracing_session = StartTracing("track_event");
144
145 while (state.KeepRunning()) {
146 TRACE_EVENT_BEGIN("benchmark", "Event", "value", 42);
147 benchmark::ClobberMemory();
148 }
149
150 tracing_session->StopBlocking();
151 PERFETTO_CHECK(!tracing_session->ReadTraceBlocking().empty());
152 }
153
BM_TracingTrackEventLambda(benchmark::State & state)154 static void BM_TracingTrackEventLambda(benchmark::State& state) {
155 auto tracing_session = StartTracing("track_event");
156
157 while (state.KeepRunning()) {
158 TRACE_EVENT_BEGIN("benchmark", "Event", [&](perfetto::EventContext ctx) {
159 auto* log = ctx.event()->set_log_message();
160 log->set_source_location_iid(42);
161 log->set_body_iid(1234);
162 });
163 benchmark::ClobberMemory();
164 }
165
166 tracing_session->StopBlocking();
167 PERFETTO_CHECK(!tracing_session->ReadTraceBlocking().empty());
168 }
169
170 } // namespace
171
172 BENCHMARK(BM_TracingDataSourceDisabled);
173 BENCHMARK(BM_TracingDataSourceLambda);
174 BENCHMARK(BM_TracingDataSourceLambdaDifferentPacketSize)->Range(1, 1000);
175 BENCHMARK(BM_TracingTrackEventBasic);
176 BENCHMARK(BM_TracingTrackEventDebugAnnotations);
177 BENCHMARK(BM_TracingTrackEventDisabled);
178 BENCHMARK(BM_TracingTrackEventLambda);
179