1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <vector>
18
19 #include "src/trace_processor/importers/common/args_tracker.h"
20 #include "src/trace_processor/importers/common/slice_tracker.h"
21 #include "src/trace_processor/storage/trace_storage.h"
22 #include "src/trace_processor/types/trace_processor_context.h"
23 #include "test/gtest_and_gmock.h"
24
25 namespace perfetto {
26 namespace trace_processor {
27 namespace {
28
29 using ::testing::ElementsAre;
30 using ::testing::Eq;
31
32 struct SliceInfo {
33 int64_t start;
34 int64_t duration;
35
operator ==perfetto::trace_processor::__anon1b5d17a20111::SliceInfo36 bool operator==(const SliceInfo& other) const {
37 return std::tie(start, duration) == std::tie(other.start, other.duration);
38 }
39 };
40
PrintTo(const SliceInfo & info,::std::ostream * os)41 inline void PrintTo(const SliceInfo& info, ::std::ostream* os) {
42 *os << "SliceInfo{" << info.start << ", " << info.duration << "}";
43 }
44
ToSliceInfo(const tables::SliceTable & slices)45 std::vector<SliceInfo> ToSliceInfo(const tables::SliceTable& slices) {
46 std::vector<SliceInfo> infos;
47 for (uint32_t i = 0; i < slices.row_count(); i++) {
48 infos.emplace_back(SliceInfo{slices.ts()[i], slices.dur()[i]});
49 }
50 return infos;
51 }
52
TEST(SliceTrackerTest,OneSliceDetailed)53 TEST(SliceTrackerTest, OneSliceDetailed) {
54 TraceProcessorContext context;
55 context.storage.reset(new TraceStorage());
56 SliceTracker tracker(&context);
57
58 constexpr TrackId track{22u};
59 tracker.Begin(2 /*ts*/, track, kNullStringId /*cat*/,
60 StringId::Raw(1) /*name*/);
61 tracker.End(10 /*ts*/, track, kNullStringId /*cat*/,
62 StringId::Raw(1) /*name*/);
63
64 const auto& slices = context.storage->slice_table();
65 EXPECT_EQ(slices.row_count(), 1u);
66 EXPECT_EQ(slices.ts()[0], 2);
67 EXPECT_EQ(slices.dur()[0], 8);
68 EXPECT_EQ(slices.track_id()[0], track);
69 EXPECT_EQ(slices.category()[0].raw_id(), 0u);
70 EXPECT_EQ(slices.name()[0].raw_id(), 1u);
71 EXPECT_EQ(slices.depth()[0], 0u);
72 EXPECT_EQ(slices.arg_set_id()[0], kInvalidArgSetId);
73 }
74
TEST(SliceTrackerTest,OneSliceWithArgs)75 TEST(SliceTrackerTest, OneSliceWithArgs) {
76 TraceProcessorContext context;
77 context.storage.reset(new TraceStorage());
78 context.global_args_tracker.reset(new GlobalArgsTracker(&context));
79 SliceTracker tracker(&context);
80
81 constexpr TrackId track{22u};
82 tracker.Begin(2 /*ts*/, track, kNullStringId /*cat*/,
83 StringId::Raw(1) /*name*/,
84 [](ArgsTracker::BoundInserter* inserter) {
85 inserter->AddArg(/*flat_key=*/StringId::Raw(1),
86 /*key=*/StringId::Raw(2),
87 /*value=*/Variadic::Integer(10));
88 });
89 tracker.End(10 /*ts*/, track, kNullStringId /*cat*/,
90 StringId::Raw(1) /*name*/,
91 [](ArgsTracker::BoundInserter* inserter) {
92 inserter->AddArg(/*flat_key=*/StringId::Raw(3),
93 /*key=*/StringId::Raw(4),
94 /*value=*/Variadic::Integer(20));
95 });
96
97 const auto& slices = context.storage->slice_table();
98 EXPECT_EQ(slices.row_count(), 1u);
99 EXPECT_EQ(slices.ts()[0], 2);
100 EXPECT_EQ(slices.dur()[0], 8);
101 EXPECT_EQ(slices.track_id()[0], track);
102 EXPECT_EQ(slices.category()[0].raw_id(), 0u);
103 EXPECT_EQ(slices.name()[0].raw_id(), 1u);
104 EXPECT_EQ(slices.depth()[0], 0u);
105 auto set_id = slices.arg_set_id()[0];
106
107 const auto& args = context.storage->arg_table();
108 EXPECT_EQ(args.arg_set_id()[0], set_id);
109 EXPECT_EQ(args.flat_key()[0].raw_id(), 1u);
110 EXPECT_EQ(args.key()[0].raw_id(), 2u);
111 EXPECT_EQ(args.int_value()[0], 10);
112 EXPECT_EQ(args.arg_set_id()[1], set_id);
113 EXPECT_EQ(args.flat_key()[1].raw_id(), 3u);
114 EXPECT_EQ(args.key()[1].raw_id(), 4u);
115 EXPECT_EQ(args.int_value()[1], 20);
116 }
117
TEST(SliceTrackerTest,TwoSliceDetailed)118 TEST(SliceTrackerTest, TwoSliceDetailed) {
119 TraceProcessorContext context;
120 context.storage.reset(new TraceStorage());
121 SliceTracker tracker(&context);
122
123 constexpr TrackId track{22u};
124 tracker.Begin(2 /*ts*/, track, kNullStringId /*cat*/,
125 StringId::Raw(1) /*name*/);
126 tracker.Begin(3 /*ts*/, track, kNullStringId /*cat*/,
127 StringId::Raw(2) /*name*/);
128 tracker.End(5 /*ts*/, track);
129 tracker.End(10 /*ts*/, track);
130
131 const auto& slices = context.storage->slice_table();
132
133 EXPECT_EQ(slices.row_count(), 2u);
134
135 uint32_t idx = 0;
136 EXPECT_EQ(slices.ts()[idx], 2);
137 EXPECT_EQ(slices.dur()[idx], 8);
138 EXPECT_EQ(slices.track_id()[idx], track);
139 EXPECT_EQ(slices.category()[idx].raw_id(), 0u);
140 EXPECT_EQ(slices.name()[idx].raw_id(), 1u);
141 EXPECT_EQ(slices.depth()[idx++], 0u);
142
143 EXPECT_EQ(slices.ts()[idx], 3);
144 EXPECT_EQ(slices.dur()[idx], 2);
145 EXPECT_EQ(slices.track_id()[idx], track);
146 EXPECT_EQ(slices.category()[idx].raw_id(), 0u);
147 EXPECT_EQ(slices.name()[idx].raw_id(), 2u);
148 EXPECT_EQ(slices.depth()[idx], 1u);
149
150 EXPECT_EQ(slices.parent_stack_id()[0], 0);
151 EXPECT_EQ(slices.stack_id()[0], slices.parent_stack_id()[1]);
152 EXPECT_NE(slices.stack_id()[1], 0);
153 }
154
TEST(SliceTrackerTest,Scoped)155 TEST(SliceTrackerTest, Scoped) {
156 TraceProcessorContext context;
157 context.storage.reset(new TraceStorage());
158 SliceTracker tracker(&context);
159
160 constexpr TrackId track{22u};
161 tracker.Begin(0 /*ts*/, track, kNullStringId, kNullStringId);
162 tracker.Begin(1 /*ts*/, track, kNullStringId, kNullStringId);
163 tracker.Scoped(2 /*ts*/, track, kNullStringId, kNullStringId, 6);
164 tracker.End(9 /*ts*/, track);
165 tracker.End(10 /*ts*/, track);
166
167 auto slices = ToSliceInfo(context.storage->slice_table());
168 EXPECT_THAT(slices,
169 ElementsAre(SliceInfo{0, 10}, SliceInfo{1, 8}, SliceInfo{2, 6}));
170 }
171
TEST(SliceTrackerTest,ParentId)172 TEST(SliceTrackerTest, ParentId) {
173 TraceProcessorContext context;
174 context.storage.reset(new TraceStorage());
175 SliceTracker tracker(&context);
176
177 constexpr TrackId track{22u};
178 tracker.Begin(100, track, kNullStringId, kNullStringId);
179 tracker.Begin(101, track, kNullStringId, kNullStringId);
180 tracker.Begin(102, track, kNullStringId, kNullStringId);
181 tracker.End(103, track);
182 tracker.End(150, track);
183 tracker.End(200, track);
184
185 SliceId parent = context.storage->slice_table().id()[0];
186 SliceId child = context.storage->slice_table().id()[1];
187 EXPECT_THAT(context.storage->slice_table().parent_id().ToVectorForTesting(),
188 ElementsAre(base::nullopt, parent, child));
189 }
190
TEST(SliceTrackerTest,IgnoreMismatchedEnds)191 TEST(SliceTrackerTest, IgnoreMismatchedEnds) {
192 TraceProcessorContext context;
193 context.storage.reset(new TraceStorage());
194 SliceTracker tracker(&context);
195
196 constexpr TrackId track{22u};
197 tracker.Begin(2 /*ts*/, track, StringId::Raw(5) /*cat*/,
198 StringId::Raw(1) /*name*/);
199 tracker.End(3 /*ts*/, track, StringId::Raw(1) /*cat*/,
200 StringId::Raw(1) /*name*/);
201 tracker.End(4 /*ts*/, track, kNullStringId /*cat*/,
202 StringId::Raw(2) /*name*/);
203 tracker.End(5 /*ts*/, track, StringId::Raw(5) /*cat*/,
204 StringId::Raw(1) /*name*/);
205
206 auto slices = ToSliceInfo(context.storage->slice_table());
207 EXPECT_THAT(slices, ElementsAre(SliceInfo{2, 3}));
208 }
209
TEST(SliceTrackerTest,ZeroLengthScoped)210 TEST(SliceTrackerTest, ZeroLengthScoped) {
211 TraceProcessorContext context;
212 context.storage.reset(new TraceStorage());
213 SliceTracker tracker(&context);
214
215 // Bug scenario: the second zero-length scoped slice prevents the first slice
216 // from being closed, leading to an inconsistency when we try to insert the
217 // final slice and it doesn't intersect with the still pending first slice.
218 constexpr TrackId track{22u};
219 tracker.Scoped(2 /*ts*/, track, kNullStringId /*cat*/,
220 StringId::Raw(1) /*name*/, 10 /* dur */);
221 tracker.Scoped(2 /*ts*/, track, kNullStringId /*cat*/,
222 StringId::Raw(1) /*name*/, 0 /* dur */);
223 tracker.Scoped(12 /*ts*/, track, kNullStringId /*cat*/,
224 StringId::Raw(1) /*name*/, 1 /* dur */);
225 tracker.Scoped(13 /*ts*/, track, kNullStringId /*cat*/,
226 StringId::Raw(1) /*name*/, 1 /* dur */);
227
228 auto slices = ToSliceInfo(context.storage->slice_table());
229 EXPECT_THAT(slices, ElementsAre(SliceInfo{2, 10}, SliceInfo{2, 0},
230 SliceInfo{12, 1}, SliceInfo{13, 1}));
231 }
232
TEST(SliceTrackerTest,DifferentTracks)233 TEST(SliceTrackerTest, DifferentTracks) {
234 TraceProcessorContext context;
235 context.storage.reset(new TraceStorage());
236 SliceTracker tracker(&context);
237
238 constexpr TrackId track_a{22u};
239 constexpr TrackId track_b{23u};
240 tracker.Begin(0 /*ts*/, track_a, kNullStringId, kNullStringId);
241 tracker.Scoped(2 /*ts*/, track_b, kNullStringId, kNullStringId, 6);
242 tracker.Scoped(3 /*ts*/, track_b, kNullStringId, kNullStringId, 4);
243 tracker.End(10 /*ts*/, track_a);
244 tracker.FlushPendingSlices();
245
246 auto slices = ToSliceInfo(context.storage->slice_table());
247 EXPECT_THAT(slices,
248 ElementsAre(SliceInfo{0, 10}, SliceInfo{2, 6}, SliceInfo{3, 4}));
249
250 EXPECT_EQ(context.storage->slice_table().track_id()[0], track_a);
251 EXPECT_EQ(context.storage->slice_table().track_id()[1], track_b);
252 EXPECT_EQ(context.storage->slice_table().track_id()[2], track_b);
253 EXPECT_EQ(context.storage->slice_table().depth()[0], 0u);
254 EXPECT_EQ(context.storage->slice_table().depth()[1], 0u);
255 EXPECT_EQ(context.storage->slice_table().depth()[2], 1u);
256 }
257
TEST(SliceTrackerTest,EndEventOutOfOrder)258 TEST(SliceTrackerTest, EndEventOutOfOrder) {
259 TraceProcessorContext context;
260 context.storage.reset(new TraceStorage());
261 SliceTracker tracker(&context);
262
263 constexpr TrackId track{22u};
264 tracker.Scoped(50 /*ts*/, track, StringId::Raw(11) /*cat*/,
265 StringId::Raw(21) /*name*/, 100 /*dur*/);
266 tracker.Begin(100 /*ts*/, track, StringId::Raw(12) /*cat*/,
267 StringId::Raw(22) /*name*/);
268
269 // This slice should now have depth 0.
270 tracker.Scoped(450 /*ts*/, track, StringId::Raw(12) /*cat*/,
271 StringId::Raw(22) /*name*/, 100 /*dur*/);
272
273 // This slice should be ignored.
274 tracker.End(500 /*ts*/, track, StringId::Raw(12) /*cat*/,
275 StringId::Raw(22) /*name*/);
276
277 tracker.Begin(800 /*ts*/, track, StringId::Raw(13) /*cat*/,
278 StringId::Raw(23) /*name*/);
279 // Null cat and name matches everything.
280 tracker.End(1000 /*ts*/, track, kNullStringId /*cat*/,
281 kNullStringId /*name*/);
282
283 // Slice will not close if category is different.
284 tracker.Begin(1100 /*ts*/, track, StringId::Raw(11) /*cat*/,
285 StringId::Raw(21) /*name*/);
286 tracker.End(1200 /*ts*/, track, StringId::Raw(12) /*cat*/,
287 StringId::Raw(21) /*name*/);
288
289 // Slice will not close if name is different.
290 tracker.Begin(1300 /*ts*/, track, StringId::Raw(11) /*cat*/,
291 StringId::Raw(21) /*name*/);
292 tracker.End(1400 /*ts*/, track, StringId::Raw(11) /*cat*/,
293 StringId::Raw(22) /*name*/);
294
295 tracker.FlushPendingSlices();
296
297 auto slices = ToSliceInfo(context.storage->slice_table());
298 EXPECT_THAT(slices, ElementsAre(SliceInfo{50, 100}, SliceInfo{100, 50},
299 SliceInfo{450, 100}, SliceInfo{800, 200},
300 SliceInfo{1100, -1}, SliceInfo{1300, 0 - 1}));
301
302 EXPECT_EQ(context.storage->slice_table().depth()[0], 0u);
303 EXPECT_EQ(context.storage->slice_table().depth()[1], 1u);
304 EXPECT_EQ(context.storage->slice_table().depth()[2], 0u);
305 EXPECT_EQ(context.storage->slice_table().depth()[3], 0u);
306 }
307
308 } // namespace
309 } // namespace trace_processor
310 } // namespace perfetto
311