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