1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved. 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 16 #include <hwext/gtest-ext.h> 17 #include <hwext/gtest-tag.h> 18 19 #include "cpu_filter.h" 20 #include "process_filter.h" 21 #include "ts_common.h" 22 23 using namespace testing::ext; 24 using namespace SysTuning::TraceStreamer; 25 namespace SysTuning { 26 namespace TraceStreamer { 27 class CpuFilterTest : public ::testing::Test { 28 public: SetUp()29 void SetUp() 30 { 31 streamFilters_.cpuFilter_ = std::make_unique<CpuFilter>(&traceDataCache_, &streamFilters_); 32 streamFilters_.processFilter_ = std::make_unique<ProcessFilter>(&traceDataCache_, &streamFilters_); 33 } 34 TearDown()35 void TearDown() {} 36 37 public: 38 TraceStreamerFilters streamFilters_; 39 TraceDataCache traceDataCache_; 40 }; 41 42 /** 43 * @tc.name: CpufilterInsertWakeupTest 44 * @tc.desc: Test CpuFilter insert WakeupEvent 45 * @tc.type: FUNC 46 */ 47 HWTEST_F(CpuFilterTest, CpufilterInsertWakeupTest, TestSize.Level1) 48 { 49 TS_LOGI("test4-1"); 50 /* InsertWakeupEvent ts, internalTid */ 51 uint64_t ts1 = 168758662877000; 52 uint64_t itid = 1; 53 streamFilters_.cpuFilter_->InsertWakeupEvent(ts1, itid); // 1st waking 54 55 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itid) == INVALID_UINT64); 56 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itid) == TASK_INVALID); 57 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 0); // 0 thread state only 58 } 59 60 /** 61 * @tc.name: CpufilterInsertSwitchTest 62 * @tc.desc: Test CpuFilter insert SwitchEvent 63 * @tc.type: FUNC 64 */ 65 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchTest, TestSize.Level1) 66 { 67 TS_LOGI("test4-2"); 68 uint64_t ts1 = 168758662919000; 69 uint64_t itidPre = 2; 70 uint64_t prePior = 120; 71 uint64_t cpu = 0; 72 uint64_t itidNext = 3; 73 uint64_t nextPior = 124; 74 75 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 76 INVALID_DATAINDEX); // 1st switch 77 printf("state of pre itid: %" PRIu64 "\n", streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre)); 78 79 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INTERRUPTIBLE); 80 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 81 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 0); 82 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 2); // 2 thread state 83 } 84 85 /** 86 * @tc.name: CpufilterInsertSwitchFromZeroThread 87 * @tc.desc: Test CpuFilter insert SwitchEvent switch from zero thread 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchFromZeroThread, TestSize.Level1) 91 { 92 TS_LOGI("test4-3"); 93 uint64_t ts1 = 168758662919000; 94 uint64_t itidPre = 0; 95 uint64_t prePior = 120; 96 uint64_t cpu = 0; 97 uint64_t itidNext = 3; 98 uint64_t nextPior = 124; 99 100 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 101 INVALID_DATAINDEX); // 1st switch 102 printf("state of pre itid: %" PRIu64 "\n", streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre)); 103 104 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INVALID); 105 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 106 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 0); 107 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 1); // 1 thread state 108 } 109 110 /** 111 * @tc.name: CpufilterInsertSwitchToZeroThread 112 * @tc.desc: Test CpuFilter insert SwitchEvent switch to zero thread 113 * @tc.type: FUNC 114 */ 115 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchToZeroThread, TestSize.Level1) 116 { 117 TS_LOGI("test4-4"); 118 uint64_t ts1 = 168758662919000; 119 uint64_t itidPre = 2; 120 uint64_t prePior = 120; 121 uint64_t cpu = 0; 122 uint64_t itidNext = 0; 123 uint64_t nextPior = 124; 124 125 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 126 INVALID_DATAINDEX); // 1st switch 127 printf("state of pre itid: %" PRIu64 "\n", streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre)); 128 129 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INTERRUPTIBLE); 130 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_INVALID); 131 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == INVALID_UINT64); 132 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 1); // 1 thread state 133 } 134 135 /** 136 * @tc.name: CpufilterInsertSwitchDoubleThread 137 * @tc.desc: Test CpuFilter insert SwitchEvent, A switch to B and B switch to A 138 * @tc.type: FUNC 139 */ 140 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchDoubleThread, TestSize.Level1) 141 { 142 TS_LOGI("test4-5"); 143 uint64_t ts1 = 168758662919000; 144 uint64_t itidPre = 2; 145 uint64_t prePior = 120; 146 uint64_t cpu = 0; 147 uint64_t itidNext = 3; 148 uint64_t nextPior = 124; 149 150 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 151 INVALID_DATAINDEX); // 1st switch 152 153 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INTERRUPTIBLE); 154 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 155 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 0); 156 157 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 2); // 2 thread state 158 159 ts1 = 168758663017000; 160 itidPre = 3; 161 prePior = 120; 162 cpu = 0; 163 itidNext = 4; 164 nextPior = 120; 165 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 166 INVALID_DATAINDEX); // 2nd switch 167 168 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 169 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 2); 170 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidPre) == 3); 171 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 4); // 4 thread state 172 } 173 174 /** 175 * @tc.name: CpufilterInsertSwitchThreeThread 176 * @tc.desc: Test CpuFilter insert SwitchEvent, A switch to B and B switch to C 177 * @tc.type: FUNC 178 */ 179 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchThreeThread, TestSize.Level1) 180 { 181 TS_LOGI("test4-6"); 182 uint64_t ts1 = 168758662919000; 183 uint64_t itidPre = 2; 184 uint64_t prePior = 120; 185 uint64_t cpu = 0; 186 uint64_t itidNext = 3; 187 uint64_t nextPior = 124; 188 189 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 190 INVALID_DATAINDEX); // 1st switch 191 192 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INTERRUPTIBLE); 193 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 194 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 0); 195 196 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 2); // 2 thread state 197 198 ts1 = 168758663017000; 199 itidPre = 3; 200 prePior = 120; 201 cpu = 0; 202 itidNext = 2; 203 nextPior = 120; 204 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_RUNNABLE, itidNext, nextPior, 205 INVALID_DATAINDEX); // 2nd switch 206 207 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 208 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 2); 209 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidPre) == 3); 210 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 4); // 4 thread state 211 } 212 213 /** 214 * @tc.name: CpufilterInsertSwitchTestZero 215 * @tc.desc: Test CpuFilter insert SwitchEvent, A switch to B and B switch to zero thread 216 * @tc.type: FUNC 217 */ 218 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchTestZero, TestSize.Level1) 219 { 220 TS_LOGI("test4-7"); 221 uint64_t ts1 = 168758662919000; 222 uint64_t itidPre = 2; 223 uint64_t prePior = 120; 224 uint64_t cpu = 0; 225 uint64_t itidNext = 3; 226 uint64_t nextPior = 124; 227 228 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_INTERRUPTIBLE, itidNext, nextPior, 229 INVALID_DATAINDEX); // 1st switch 230 231 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidPre) == TASK_INTERRUPTIBLE); 232 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 233 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 0); 234 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 2); // 2 thread state 235 236 ts1 = 168758663017000; 237 itidPre = 0; 238 prePior = 120; 239 cpu = 0; 240 itidNext = 4; 241 nextPior = 120; 242 streamFilters_.cpuFilter_->InsertSwitchEvent(ts1, cpu, itidPre, prePior, TASK_RUNNABLE, itidNext, nextPior, 243 INVALID_DATAINDEX); // 2nd switch 244 245 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itidNext) == TASK_RUNNING); 246 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itidNext) == 2); 247 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 3); // 4 thread state 248 } 249 250 /** 251 * @tc.name: CpufiltertWakeingTest 252 * @tc.desc: Test CpuFilter insert Waking Event 253 * @tc.type: FUNC 254 */ 255 HWTEST_F(CpuFilterTest, CpufiltertWakeingTest, TestSize.Level1) 256 { 257 TS_LOGI("test4-8"); 258 uint64_t ts1 = 168758662919000; 259 uint64_t itid = 2; 260 261 streamFilters_.cpuFilter_->InsertWakeupEvent(ts1, itid); 262 263 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itid) == TASK_INVALID); 264 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itid) == INVALID_UINT64); 265 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 0); // 0 thread state 266 } 267 268 /** 269 * @tc.name: CpufiltertWakingTwice 270 * @tc.desc: Test CpuFilter insert Waking Event, one thread waking twice 271 * @tc.type: FUNC 272 */ 273 HWTEST_F(CpuFilterTest, CpufiltertWakingTwice, TestSize.Level1) 274 { 275 TS_LOGI("test4-9"); 276 uint64_t ts1 = 168758662919000; 277 uint64_t itid = 2; 278 279 streamFilters_.cpuFilter_->InsertWakeupEvent(ts1, itid); 280 ts1 = 168758662929000; 281 itid = 4; 282 streamFilters_.cpuFilter_->InsertWakeupEvent(ts1, itid); 283 284 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(itid) == TASK_INVALID); 285 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(itid) == INVALID_UINT64); 286 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 0); // 0 thread state 287 } 288 289 /** 290 * @tc.name: CpufilterInsertSwitchTestFull 291 * @tc.desc: Parsing multiple switch and wakeup alternates 292 * @tc.type: FUNC 293 */ 294 HWTEST_F(CpuFilterTest, CpufilterInsertSwitchTestFull, TestSize.Level1) 295 { 296 TS_LOGI("test4-10"); 297 /* InsertWakeupEvent ts, internalTid */ 298 /* InsertSwitchEvent ts, cpu, prevPid, prevPior, prevState, nextPid, nextPior */ 299 streamFilters_.cpuFilter_->InsertWakeupEvent(168758662877000, 1); // 1st waking 300 301 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(1) == INVALID_UINT64); 302 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(1) == TASK_INVALID); 303 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 0); // 0 thread state only 304 305 streamFilters_.cpuFilter_->InsertSwitchEvent(168758662919000, 0, 1, 120, TASK_INTERRUPTIBLE, 2, 124, 306 INVALID_DATAINDEX); // 1st switch 307 308 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(1) == TASK_INTERRUPTIBLE); 309 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(2) == TASK_RUNNING); 310 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(2) == 0); 311 // 2 thread state, the waking event add a runnable state 312 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 2); 313 streamFilters_.cpuFilter_->InsertSwitchEvent(168758663017000, 0, 0, 120, TASK_RUNNABLE, 4, 120, 314 INVALID_DATAINDEX); // 2nd switch 315 316 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(4) == TASK_RUNNING); 317 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(4) == 2); 318 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 3); // 4 thread state 319 320 streamFilters_.cpuFilter_->InsertWakeupEvent(168758663078000, 0); // 2nd waking 321 322 streamFilters_.cpuFilter_->InsertWakeupEvent(168758663092000, 0); // 3rd waking 323 324 streamFilters_.cpuFilter_->InsertSwitchEvent(168758663107000, 0, 2, 124, TASK_RUNNABLE, 5, 98, 325 INVALID_DATAINDEX); // 3rd switch 326 327 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(5) == TASK_RUNNING); 328 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(2) == TASK_RUNNABLE); 329 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(5) == 3); 330 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(2) == 4); 331 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 5); // 6 thread state 332 333 streamFilters_.cpuFilter_->InsertSwitchEvent(168758663126000, 0, 5, 98, TASK_INTERRUPTIBLE, 2, 124, 334 INVALID_DATAINDEX); // 4th switch 335 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(2) == TASK_RUNNING); 336 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(5) == TASK_INTERRUPTIBLE); 337 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(2) == 5); 338 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(5) == 6); 339 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 7); // 8 thread state 340 341 streamFilters_.cpuFilter_->InsertSwitchEvent(168758663136000, 3, 5, 120, TASK_RUNNABLE, 6, 120, 342 INVALID_DATAINDEX); // 5th switch 343 344 EXPECT_TRUE(streamFilters_.cpuFilter_->StateOfInternalTidInStateTable(6) == TASK_RUNNING); 345 EXPECT_TRUE(streamFilters_.cpuFilter_->RowOfInternalTidInStateTable(6) == 7); 346 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->Size() == 9); // 10 thread state 347 348 // after 3rd switch 349 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->DursData()[1] == INVALID_UINT64); 350 // after 4th switch 351 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->DursData()[6] == 168758663136000 - 168758663126000); 352 EXPECT_TRUE(traceDataCache_.GetThreadStateData()->DursData()[7] == INVALID_UINT64); 353 } 354 } // namespace TraceStreamer 355 } // namespace SysTuning 356