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 "src/trace_processor/event_tracker.h"
18
19 #include "perfetto/base/logging.h"
20 #include "src/trace_processor/args_tracker.h"
21 #include "src/trace_processor/importers/ftrace/sched_event_tracker.h"
22 #include "src/trace_processor/process_tracker.h"
23 #include "src/trace_processor/track_tracker.h"
24 #include "test/gtest_and_gmock.h"
25
26 namespace perfetto {
27 namespace trace_processor {
28 namespace {
29
30 using ::testing::_;
31 using ::testing::InSequence;
32 using ::testing::Invoke;
33
34 class EventTrackerTest : public ::testing::Test {
35 public:
EventTrackerTest()36 EventTrackerTest() {
37 context.storage.reset(new TraceStorage());
38 context.global_args_tracker.reset(new GlobalArgsTracker(&context));
39 context.args_tracker.reset(new ArgsTracker(&context));
40 context.process_tracker.reset(new ProcessTracker(&context));
41 context.event_tracker.reset(new EventTracker(&context));
42 context.track_tracker.reset(new TrackTracker(&context));
43 sched_tracker = SchedEventTracker::GetOrCreate(&context);
44 }
45
46 protected:
47 TraceProcessorContext context;
48 SchedEventTracker* sched_tracker;
49 };
50
TEST_F(EventTrackerTest,InsertSecondSched)51 TEST_F(EventTrackerTest, InsertSecondSched) {
52 uint32_t cpu = 3;
53 int64_t timestamp = 100;
54 uint32_t pid_1 = 2;
55 int64_t prev_state = 32;
56 static const char kCommProc1[] = "process1";
57 static const char kCommProc2[] = "process2";
58 uint32_t pid_2 = 4;
59 int32_t prio = 1024;
60
61 sched_tracker->PushSchedSwitch(cpu, timestamp, pid_1, kCommProc2, prio,
62 prev_state, pid_2, kCommProc1, prio);
63 ASSERT_EQ(context.storage->sched_slice_table().row_count(), 1ul);
64
65 sched_tracker->PushSchedSwitch(cpu, timestamp + 1, pid_2, kCommProc1, prio,
66 prev_state, pid_1, kCommProc2, prio);
67
68 ASSERT_EQ(context.storage->sched_slice_table().row_count(), 2ul);
69
70 const auto& timestamps = context.storage->sched_slice_table().ts();
71 ASSERT_EQ(timestamps[0], timestamp);
72 ASSERT_EQ(context.storage->thread_table().start_ts()[1], base::nullopt);
73
74 auto name =
75 context.storage->GetString(context.storage->thread_table().name()[1]);
76 ASSERT_STREQ(name.c_str(), kCommProc1);
77 ASSERT_EQ(context.storage->sched_slice_table().utid()[0], 1u);
78 ASSERT_EQ(context.storage->sched_slice_table().dur()[0], 1);
79 }
80
TEST_F(EventTrackerTest,InsertThirdSched_SameThread)81 TEST_F(EventTrackerTest, InsertThirdSched_SameThread) {
82 uint32_t cpu = 3;
83 int64_t timestamp = 100;
84 int64_t prev_state = 32;
85 static const char kCommProc1[] = "process1";
86 static const char kCommProc2[] = "process2";
87 int32_t prio = 1024;
88
89 sched_tracker->PushSchedSwitch(cpu, timestamp, /*tid=*/4, kCommProc2, prio,
90 prev_state,
91 /*tid=*/2, kCommProc1, prio);
92 ASSERT_EQ(context.storage->sched_slice_table().row_count(), 1u);
93
94 sched_tracker->PushSchedSwitch(cpu, timestamp + 1, /*tid=*/2, kCommProc1,
95 prio, prev_state,
96 /*tid=*/4, kCommProc2, prio);
97 sched_tracker->PushSchedSwitch(cpu, timestamp + 11, /*tid=*/4, kCommProc2,
98 prio, prev_state,
99 /*tid=*/2, kCommProc1, prio);
100 sched_tracker->PushSchedSwitch(cpu, timestamp + 31, /*tid=*/2, kCommProc1,
101 prio, prev_state,
102 /*tid=*/4, kCommProc2, prio);
103 ASSERT_EQ(context.storage->sched_slice_table().row_count(), 4ul);
104
105 const auto& timestamps = context.storage->sched_slice_table().ts();
106 ASSERT_EQ(timestamps[0], timestamp);
107 ASSERT_EQ(context.storage->thread_table().start_ts()[1], base::nullopt);
108 ASSERT_EQ(context.storage->sched_slice_table().dur()[0], 1u);
109 ASSERT_EQ(context.storage->sched_slice_table().dur()[1], 11u - 1u);
110 ASSERT_EQ(context.storage->sched_slice_table().dur()[2], 31u - 11u);
111 ASSERT_EQ(context.storage->sched_slice_table().utid()[0],
112 context.storage->sched_slice_table().utid()[2]);
113 }
114
TEST_F(EventTrackerTest,CounterDuration)115 TEST_F(EventTrackerTest, CounterDuration) {
116 uint32_t cpu = 3;
117 int64_t timestamp = 100;
118 StringId name_id = kNullStringId;
119
120 TrackId track = context.track_tracker->InternCpuCounterTrack(name_id, cpu);
121 context.event_tracker->PushCounter(timestamp, 1000, track);
122 context.event_tracker->PushCounter(timestamp + 1, 4000, track);
123 context.event_tracker->PushCounter(timestamp + 3, 5000, track);
124 context.event_tracker->PushCounter(timestamp + 9, 1000, track);
125
126 ASSERT_EQ(context.storage->counter_track_table().row_count(), 1ul);
127
128 ASSERT_EQ(context.storage->counter_table().row_count(), 4ul);
129 ASSERT_EQ(context.storage->counter_table().ts()[0], timestamp);
130 ASSERT_DOUBLE_EQ(context.storage->counter_table().value()[0], 1000);
131
132 ASSERT_EQ(context.storage->counter_table().ts()[1], timestamp + 1);
133 ASSERT_DOUBLE_EQ(context.storage->counter_table().value()[1], 4000);
134
135 ASSERT_EQ(context.storage->counter_table().ts()[2], timestamp + 3);
136 ASSERT_DOUBLE_EQ(context.storage->counter_table().value()[2], 5000);
137 }
138
139 } // namespace
140 } // namespace trace_processor
141 } // namespace perfetto
142