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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <unordered_map> 20 21 #include "cpu_filter.h" 22 #include "htrace_cpu_detail_parser.h" 23 #include "parser/common_types.h" 24 #include "trace_plugin_result.pb.h" 25 #include "trace_plugin_result.pbreader.h" 26 #include "trace_streamer_filters.h" 27 #include "trace_streamer_selector.h" 28 29 using namespace testing::ext; 30 using namespace SysTuning::TraceStreamer; 31 namespace SysTuning { 32 namespace TraceStreamer { 33 const uint64_t TIMESTAMP = 1616439852302; 34 const std::string THREAD_NAME_01 = "ACCS0"; 35 const std::string THREAD_NAME_02 = "HeapTaskDaemon"; 36 const uint32_t PRIORITY_01 = 120; 37 const uint32_t PRIORITY_02 = 124; 38 const uint32_t PID_01 = 2716; 39 const uint32_t PID_02 = 2532; 40 class HtraceEventParserTest : public ::testing::Test { 41 public: SetUp()42 void SetUp() 43 { 44 stream_.InitFilter(); 45 } 46 TearDown()47 void TearDown() {} 48 49 public: 50 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 51 }; 52 53 /** 54 * @tc.name: ParseSchedSwitchEvent 55 * @tc.desc: Parse a schedswitch event in htrace format 56 * @tc.type: FUNC 57 */ 58 HWTEST_F(HtraceEventParserTest, ParseSchedSwitchEvent, TestSize.Level1) 59 { 60 TS_LOGI("test14-1"); 61 SchedSwitchFormat *event = new SchedSwitchFormat(); 62 event->set_prev_prio(PRIORITY_01); 63 event->set_next_prio(PRIORITY_02); 64 event->set_prev_pid(PID_01); 65 event->set_next_pid(PID_02); 66 event->set_prev_comm(THREAD_NAME_01); 67 event->set_next_comm(THREAD_NAME_02); 68 event->set_prev_state(1); 69 70 TracePluginResult tracePacket; 71 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 72 ftraceCpuDetail->set_cpu(0); 73 ftraceCpuDetail->set_overwrite(0); 74 auto ftraceEvent = ftraceCpuDetail->add_event(); 75 76 ftraceEvent->set_timestamp(TIMESTAMP); 77 ftraceEvent->set_tgid(1); 78 ftraceEvent->set_comm(THREAD_NAME_02); 79 ftraceEvent->unsafe_arena_set_allocated_sched_switch_format(event); 80 81 PbreaderDataSegment dataSeg; 82 dataSeg.clockId = TS_CLOCK_BOOTTIME; 83 std::string cpuDetailStrMsg = ""; 84 tracePacket.SerializeToString(&cpuDetailStrMsg); 85 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 86 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 87 dataSeg.seg->size()); 88 dataSeg.protoData = cpuDetailBytesView; 89 90 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 91 bool haveSplit = false; 92 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 93 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 94 htraceCpuDetailParser.FilterAllEvents(); 95 EXPECT_TRUE(1); 96 auto realTimeStamp = stream_.traceDataCache_->GetConstSchedSliceData().TimeStampData()[0]; 97 EXPECT_TRUE(TIMESTAMP == realTimeStamp); 98 auto realCpu = stream_.traceDataCache_->GetConstSchedSliceData().CpusData()[0]; 99 EXPECT_TRUE(0 == realCpu); 100 } 101 102 /** 103 * @tc.name: ParseFtraceCpuDetailMsgHasNoEvent 104 * @tc.desc: FtraceCpuDetailMsg has no ftrace event 105 * @tc.type: FUNC 106 */ 107 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgHasNoEvent, TestSize.Level1) 108 { 109 TS_LOGI("test14-2"); 110 TracePluginResult tracePacket; 111 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 112 ftraceCpuDetail->set_cpu(0); 113 ftraceCpuDetail->set_overwrite(0); 114 115 PbreaderDataSegment dataSeg; 116 dataSeg.clockId = TS_CLOCK_BOOTTIME; 117 std::string cpuDetailStrMsg = ""; 118 tracePacket.SerializeToString(&cpuDetailStrMsg); 119 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 120 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 121 dataSeg.seg->size()); 122 dataSeg.protoData = cpuDetailBytesView; 123 124 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 125 bool haveSplit = false; 126 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 127 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 128 htraceCpuDetailParser.FilterAllEvents(); 129 130 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST); 131 EXPECT_TRUE(0 == eventCount); 132 } 133 134 /** 135 * @tc.name: ParseFtraceCpuDetailMsgOverwriteTrue 136 * @tc.desc: FtraceCpuDetailMsg overwrit is true 137 * @tc.type: FUNC 138 */ 139 HWTEST_F(HtraceEventParserTest, ParseFtraceCpuDetailMsgOverwriteTrue, TestSize.Level1) 140 { 141 TS_LOGI("test14-3"); 142 SchedSwitchFormat *event = new SchedSwitchFormat(); 143 event->set_prev_prio(PRIORITY_01); 144 event->set_next_prio(PRIORITY_02); 145 event->set_prev_pid(PID_01); 146 event->set_next_pid(PID_02); 147 event->set_prev_comm(THREAD_NAME_01); 148 event->set_next_comm(THREAD_NAME_02); 149 event->set_prev_state(1); 150 151 TracePluginResult tracePacket; 152 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 153 ftraceCpuDetail->set_cpu(0); 154 ftraceCpuDetail->set_overwrite(1); 155 auto ftraceEvent = ftraceCpuDetail->add_event(); 156 157 ftraceEvent->set_timestamp(TIMESTAMP); 158 ftraceEvent->set_tgid(1); 159 ftraceEvent->set_comm(THREAD_NAME_02); 160 ftraceEvent->set_allocated_sched_switch_format(event); 161 162 PbreaderDataSegment dataSeg; 163 dataSeg.clockId = TS_CLOCK_BOOTTIME; 164 std::string cpuDetailStrMsg = ""; 165 tracePacket.SerializeToString(&cpuDetailStrMsg); 166 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 167 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 168 dataSeg.seg->size()); 169 dataSeg.protoData = cpuDetailBytesView; 170 171 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 172 bool haveSplit = false; 173 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 174 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 175 htraceCpuDetailParser.FilterAllEvents(); 176 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_OTHER, STAT_EVENT_DATA_LOST); 177 EXPECT_TRUE(1 == eventCount); 178 } 179 180 /** 181 * @tc.name: ParseTaskRenameEvent 182 * @tc.desc: Parse a task_rename event in htrace format 183 * @tc.type: FUNC 184 */ 185 HWTEST_F(HtraceEventParserTest, ParseTaskRenameEvent, TestSize.Level1) 186 { 187 TS_LOGI("test14-4"); 188 TaskRenameFormat *taskRenameEvent = new TaskRenameFormat(); 189 taskRenameEvent->set_pid(PID_01); 190 taskRenameEvent->set_oldcomm(THREAD_NAME_01); 191 taskRenameEvent->set_newcomm(THREAD_NAME_02); 192 taskRenameEvent->set_oom_score_adj(1); 193 194 TracePluginResult tracePacket; 195 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 196 ftraceCpuDetail->set_cpu(0); 197 ftraceCpuDetail->set_overwrite(0); 198 auto ftraceEvent = ftraceCpuDetail->add_event(); 199 200 ftraceEvent->set_timestamp(TIMESTAMP); 201 ftraceEvent->set_tgid(1); 202 ftraceEvent->set_comm(THREAD_NAME_02); 203 ftraceEvent->set_allocated_task_rename_format(taskRenameEvent); 204 205 PbreaderDataSegment dataSeg; 206 dataSeg.clockId = TS_CLOCK_BOOTTIME; 207 std::string cpuDetailStrMsg = ""; 208 tracePacket.SerializeToString(&cpuDetailStrMsg); 209 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 210 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 211 dataSeg.seg->size()); 212 dataSeg.protoData = cpuDetailBytesView; 213 214 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 215 bool haveSplit = false; 216 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 217 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 218 htraceCpuDetailParser.FilterAllEvents(); 219 auto eventCount = 220 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_RENAME, STAT_EVENT_RECEIVED); 221 EXPECT_TRUE(1 == eventCount); 222 } 223 224 /** 225 * @tc.name: ParseTaskNewtaskEvent 226 * @tc.desc: Parse a task_newtask event in htrace format 227 * @tc.type: FUNC 228 */ 229 HWTEST_F(HtraceEventParserTest, ParseTaskNewtaskEvent, TestSize.Level1) 230 { 231 TS_LOGI("test14-5"); 232 TaskNewtaskFormat *newTaskEvent = new TaskNewtaskFormat(); 233 newTaskEvent->set_pid(PID_01); 234 newTaskEvent->set_comm(THREAD_NAME_01); 235 newTaskEvent->set_clone_flags(0); 236 newTaskEvent->set_oom_score_adj(1); 237 238 TracePluginResult tracePacket; 239 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 240 ftraceCpuDetail->set_cpu(0); 241 ftraceCpuDetail->set_overwrite(0); 242 auto ftraceEvent = ftraceCpuDetail->add_event(); 243 244 ftraceEvent->set_timestamp(TIMESTAMP); 245 ftraceEvent->set_tgid(1); 246 ftraceEvent->set_comm(THREAD_NAME_02); 247 ftraceEvent->set_allocated_task_newtask_format(newTaskEvent); 248 249 PbreaderDataSegment dataSeg; 250 dataSeg.clockId = TS_CLOCK_BOOTTIME; 251 std::string cpuDetailStrMsg = ""; 252 tracePacket.SerializeToString(&cpuDetailStrMsg); 253 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 254 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 255 dataSeg.seg->size()); 256 dataSeg.protoData = cpuDetailBytesView; 257 258 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 259 bool haveSplit = false; 260 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 261 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 262 htraceCpuDetailParser.FilterAllEvents(); 263 auto eventCount = 264 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED); 265 EXPECT_TRUE(1 == eventCount); 266 } 267 268 /** 269 * @tc.name: ParseSchedWakeupEvent 270 * @tc.desc: Parse a sched_wakeup event in htrace format 271 * @tc.type: FUNC 272 */ 273 HWTEST_F(HtraceEventParserTest, ParseSchedWakeupEvent, TestSize.Level1) 274 { 275 TS_LOGI("test14-6"); 276 SchedWakeupFormat *wakeupEvent = new SchedWakeupFormat(); 277 wakeupEvent->set_comm(THREAD_NAME_01); 278 wakeupEvent->set_pid(PRIORITY_02); 279 wakeupEvent->set_prio(PID_01); 280 wakeupEvent->set_target_cpu(1); 281 282 TracePluginResult tracePacket; 283 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 284 ftraceCpuDetail->set_cpu(0); 285 ftraceCpuDetail->set_overwrite(0); 286 auto ftraceEvent = ftraceCpuDetail->add_event(); 287 288 ftraceEvent->set_timestamp(TIMESTAMP); 289 ftraceEvent->set_tgid(1); 290 ftraceEvent->set_comm(THREAD_NAME_02); 291 ftraceEvent->set_allocated_sched_wakeup_format(wakeupEvent); 292 293 PbreaderDataSegment dataSeg; 294 dataSeg.clockId = TS_CLOCK_BOOTTIME; 295 std::string cpuDetailStrMsg = ""; 296 tracePacket.SerializeToString(&cpuDetailStrMsg); 297 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 298 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 299 dataSeg.seg->size()); 300 dataSeg.protoData = cpuDetailBytesView; 301 302 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 303 bool haveSplit = false; 304 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 305 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 306 htraceCpuDetailParser.FilterAllEvents(); 307 auto eventCount = 308 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED); 309 EXPECT_TRUE(1 == eventCount); 310 } 311 312 /** 313 * @tc.name: ParseSchedWakingEvent 314 * @tc.desc: Parse a sched_waking event in htrace format 315 * @tc.type: FUNC 316 */ 317 HWTEST_F(HtraceEventParserTest, ParseSchedWakingEvent, TestSize.Level1) 318 { 319 TS_LOGI("test14-7"); 320 SchedWakingFormat *wakingEvent = new SchedWakingFormat(); 321 wakingEvent->set_comm(THREAD_NAME_01); 322 wakingEvent->set_pid(PRIORITY_02); 323 wakingEvent->set_prio(PID_01); 324 wakingEvent->set_target_cpu(1); 325 326 TracePluginResult tracePacket; 327 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 328 ftraceCpuDetail->set_cpu(0); 329 ftraceCpuDetail->set_overwrite(0); 330 auto ftraceEvent = ftraceCpuDetail->add_event(); 331 332 ftraceEvent->set_timestamp(TIMESTAMP); 333 ftraceEvent->set_tgid(1); 334 ftraceEvent->set_comm(THREAD_NAME_02); 335 ftraceEvent->set_allocated_sched_waking_format(wakingEvent); 336 337 PbreaderDataSegment dataSeg; 338 dataSeg.clockId = TS_CLOCK_BOOTTIME; 339 std::string cpuDetailStrMsg = ""; 340 tracePacket.SerializeToString(&cpuDetailStrMsg); 341 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 342 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 343 dataSeg.seg->size()); 344 dataSeg.protoData = cpuDetailBytesView; 345 346 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 347 bool haveSplit = false; 348 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 349 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 350 htraceCpuDetailParser.FilterAllEvents(); 351 auto eventCount = 352 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED); 353 EXPECT_TRUE(1 == eventCount); 354 } 355 356 /** 357 * @tc.name: ParseCpuIdleEvent 358 * @tc.desc: Parse a cpuIdle event in htrace format 359 * @tc.type: FUNC 360 */ 361 HWTEST_F(HtraceEventParserTest, ParseCpuIdleEvent, TestSize.Level1) 362 { 363 TS_LOGI("test14-8"); 364 CpuIdleFormat *cpuIdleEvent = new CpuIdleFormat(); 365 cpuIdleEvent->set_cpu_id(0); 366 cpuIdleEvent->set_state(1); 367 368 TracePluginResult tracePacket; 369 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 370 ftraceCpuDetail->set_cpu(0); 371 ftraceCpuDetail->set_overwrite(0); 372 auto ftraceEvent = ftraceCpuDetail->add_event(); 373 374 ftraceEvent->set_timestamp(TIMESTAMP); 375 ftraceEvent->set_tgid(1); 376 ftraceEvent->set_comm(THREAD_NAME_02); 377 ftraceEvent->set_allocated_cpu_idle_format(cpuIdleEvent); 378 379 PbreaderDataSegment dataSeg; 380 dataSeg.clockId = TS_CLOCK_BOOTTIME; 381 std::string cpuDetailStrMsg = ""; 382 tracePacket.SerializeToString(&cpuDetailStrMsg); 383 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 384 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 385 dataSeg.seg->size()); 386 dataSeg.protoData = cpuDetailBytesView; 387 388 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 389 bool haveSplit = false; 390 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 391 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 392 htraceCpuDetailParser.FilterAllEvents(); 393 auto eventCount = 394 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED); 395 EXPECT_TRUE(1 == eventCount); 396 } 397 398 /** 399 * @tc.name: ParseCpuFrequencyEvent 400 * @tc.desc: Parse a CpuFrequency event in htrace format 401 * @tc.type: FUNC 402 */ 403 HWTEST_F(HtraceEventParserTest, ParseCpuFrequencyEvent, TestSize.Level1) 404 { 405 TS_LOGI("test14-9"); 406 CpuFrequencyFormat *cpuFrequencyEvent = new CpuFrequencyFormat(); 407 cpuFrequencyEvent->set_cpu_id(0); 408 cpuFrequencyEvent->set_state(1); 409 410 TracePluginResult tracePacket; 411 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 412 ftraceCpuDetail->set_cpu(0); 413 ftraceCpuDetail->set_overwrite(0); 414 auto ftraceEvent = ftraceCpuDetail->add_event(); 415 416 ftraceEvent->set_timestamp(TIMESTAMP); 417 ftraceEvent->set_tgid(2); 418 ftraceEvent->set_comm(THREAD_NAME_02); 419 ftraceEvent->set_allocated_cpu_frequency_format(cpuFrequencyEvent); 420 421 PbreaderDataSegment dataSeg; 422 dataSeg.clockId = TS_CLOCK_BOOTTIME; 423 std::string cpuDetailStrMsg = ""; 424 tracePacket.SerializeToString(&cpuDetailStrMsg); 425 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 426 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 427 dataSeg.seg->size()); 428 dataSeg.protoData = cpuDetailBytesView; 429 430 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 431 bool haveSplit = false; 432 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 433 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 434 htraceCpuDetailParser.FilterAllEvents(); 435 auto eventCount = 436 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED); 437 EXPECT_TRUE(1 == eventCount); 438 } 439 440 /** 441 * @tc.name: ParseWorkqueueExecuteStartEvent 442 * @tc.desc: Parse a WorkqueueExecuteStart event in htrace format 443 * @tc.type: FUNC 444 */ 445 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteStartEvent, TestSize.Level1) 446 { 447 TS_LOGI("test14-10"); 448 stream_.traceDataCache_->GetSymbolsData()->UpdateSymbol(1, 1); 449 auto funcNum = stream_.traceDataCache_->GetSymbolsData()->GetFunc(1); 450 WorkqueueExecuteStartFormat *workqueueExecuteStartEvent = new WorkqueueExecuteStartFormat(); 451 workqueueExecuteStartEvent->set_work(0); 452 workqueueExecuteStartEvent->set_function(1); 453 454 TracePluginResult tracePacket; 455 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 456 ftraceCpuDetail->set_cpu(0); 457 ftraceCpuDetail->set_overwrite(0); 458 auto ftraceEvent = ftraceCpuDetail->add_event(); 459 460 ftraceEvent->set_timestamp(TIMESTAMP); 461 ftraceEvent->set_tgid(1); 462 ftraceEvent->set_comm(THREAD_NAME_02); 463 ftraceEvent->set_allocated_workqueue_execute_start_format(workqueueExecuteStartEvent); 464 465 PbreaderDataSegment dataSeg; 466 dataSeg.clockId = TS_CLOCK_BOOTTIME; 467 std::string cpuDetailStrMsg = ""; 468 tracePacket.SerializeToString(&cpuDetailStrMsg); 469 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 470 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 471 dataSeg.seg->size()); 472 dataSeg.protoData = cpuDetailBytesView; 473 474 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 475 bool haveSplit = false; 476 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 477 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 478 htraceCpuDetailParser.FilterAllEvents(); 479 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_START, 480 STAT_EVENT_RECEIVED); 481 EXPECT_TRUE(1 == eventCount); 482 } 483 484 /** 485 * @tc.name: ParseWorkqueueExecuteEndEvent 486 * @tc.desc: Parse a WorkqueueExecuteEnd event in htrace format 487 * @tc.type: FUNC 488 */ 489 HWTEST_F(HtraceEventParserTest, ParseWorkqueueExecuteEndEvent, TestSize.Level1) 490 { 491 TS_LOGI("test14-11"); 492 WorkqueueExecuteEndFormat *workqueueExecuteEndEvent = new WorkqueueExecuteEndFormat(); 493 workqueueExecuteEndEvent->set_work(0); 494 495 TracePluginResult tracePacket; 496 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 497 ftraceCpuDetail->set_cpu(0); 498 ftraceCpuDetail->set_overwrite(0); 499 auto ftraceEvent = ftraceCpuDetail->add_event(); 500 501 ftraceEvent->set_timestamp(TIMESTAMP); 502 ftraceEvent->set_tgid(1); 503 ftraceEvent->set_comm(THREAD_NAME_02); 504 ftraceEvent->set_allocated_workqueue_execute_end_format(workqueueExecuteEndEvent); 505 506 PbreaderDataSegment dataSeg; 507 dataSeg.clockId = TS_CLOCK_BOOTTIME; 508 std::string cpuDetailStrMsg = ""; 509 tracePacket.SerializeToString(&cpuDetailStrMsg); 510 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 511 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 512 dataSeg.seg->size()); 513 dataSeg.protoData = cpuDetailBytesView; 514 515 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 516 bool haveSplit = false; 517 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 518 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 519 htraceCpuDetailParser.FilterAllEvents(); 520 auto eventCount = 521 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED); 522 EXPECT_TRUE(1 == eventCount); 523 } 524 525 /** 526 * @tc.name: ParseClockDisableEvent 527 * @tc.desc: Parse a clock_Disable event in htrace format 528 * @tc.type: FUNC 529 */ 530 HWTEST_F(HtraceEventParserTest, ParseClockDisableEvent, TestSize.Level1) 531 { 532 TS_LOGI("test14-12"); 533 ClockDisableFormat *clockDisableEvent = new ClockDisableFormat(); 534 clockDisableEvent->set_name(THREAD_NAME_02); 535 clockDisableEvent->set_cpu_id(0); 536 clockDisableEvent->set_state(1); 537 538 TracePluginResult tracePacket; 539 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 540 ftraceCpuDetail->set_cpu(0); 541 ftraceCpuDetail->set_overwrite(0); 542 auto ftraceEvent = ftraceCpuDetail->add_event(); 543 544 ftraceEvent->set_timestamp(TIMESTAMP); 545 ftraceEvent->set_tgid(2); 546 ftraceEvent->set_comm(THREAD_NAME_02); 547 ftraceEvent->set_allocated_clock_disable_format(clockDisableEvent); 548 549 PbreaderDataSegment dataSeg; 550 dataSeg.clockId = TS_CLOCK_BOOTTIME; 551 std::string cpuDetailStrMsg = ""; 552 tracePacket.SerializeToString(&cpuDetailStrMsg); 553 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 554 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 555 dataSeg.seg->size()); 556 dataSeg.protoData = cpuDetailBytesView; 557 558 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 559 bool haveSplit = false; 560 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 561 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 562 htraceCpuDetailParser.FilterAllEvents(); 563 auto eventCount = 564 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED); 565 EXPECT_TRUE(1 == eventCount); 566 } 567 568 /** 569 * @tc.name: ParseClockEnableEvent 570 * @tc.desc: Parse a clock_Enable event in htrace format 571 * @tc.type: FUNC 572 */ 573 HWTEST_F(HtraceEventParserTest, ParseClockEnableEvent, TestSize.Level1) 574 { 575 TS_LOGI("test14-13"); 576 ClockEnableFormat *clockEnableEvent = new ClockEnableFormat(); 577 clockEnableEvent->set_name(THREAD_NAME_02); 578 clockEnableEvent->set_cpu_id(0); 579 clockEnableEvent->set_state(1); 580 581 TracePluginResult tracePacket; 582 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 583 ftraceCpuDetail->set_cpu(0); 584 ftraceCpuDetail->set_overwrite(0); 585 auto ftraceEvent = ftraceCpuDetail->add_event(); 586 587 ftraceEvent->set_timestamp(TIMESTAMP); 588 ftraceEvent->set_tgid(2); 589 ftraceEvent->set_comm(THREAD_NAME_02); 590 ftraceEvent->set_allocated_clock_enable_format(clockEnableEvent); 591 592 PbreaderDataSegment dataSeg; 593 dataSeg.clockId = TS_CLOCK_BOOTTIME; 594 std::string cpuDetailStrMsg = ""; 595 tracePacket.SerializeToString(&cpuDetailStrMsg); 596 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 597 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 598 dataSeg.seg->size()); 599 dataSeg.protoData = cpuDetailBytesView; 600 601 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 602 bool haveSplit = false; 603 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 604 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 605 htraceCpuDetailParser.FilterAllEvents(); 606 auto eventCount = 607 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED); 608 EXPECT_TRUE(1 == eventCount); 609 } 610 611 /** 612 * @tc.name: ParseClockSetRateEvent 613 * @tc.desc: Parse a clock_set_rate event in htrace format 614 * @tc.type: FUNC 615 */ 616 HWTEST_F(HtraceEventParserTest, ParseClockSetRateEvent, TestSize.Level1) 617 { 618 TS_LOGI("test14-14"); 619 ClockSetRateFormat *clockSetRateEvent = new ClockSetRateFormat(); 620 clockSetRateEvent->set_name(THREAD_NAME_02); 621 clockSetRateEvent->set_cpu_id(0); 622 clockSetRateEvent->set_state(1); 623 624 TracePluginResult tracePacket; 625 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 626 ftraceCpuDetail->set_cpu(0); 627 ftraceCpuDetail->set_overwrite(0); 628 auto ftraceEvent = ftraceCpuDetail->add_event(); 629 630 ftraceEvent->set_timestamp(TIMESTAMP); 631 ftraceEvent->set_tgid(2); 632 ftraceEvent->set_comm(THREAD_NAME_02); 633 ftraceEvent->set_allocated_clock_set_rate_format(clockSetRateEvent); 634 635 PbreaderDataSegment dataSeg; 636 dataSeg.clockId = TS_CLOCK_BOOTTIME; 637 std::string cpuDetailStrMsg = ""; 638 tracePacket.SerializeToString(&cpuDetailStrMsg); 639 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 640 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 641 dataSeg.seg->size()); 642 dataSeg.protoData = cpuDetailBytesView; 643 644 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 645 bool haveSplit = false; 646 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 647 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 648 htraceCpuDetailParser.FilterAllEvents(); 649 auto eventCount = 650 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED); 651 EXPECT_TRUE(1 == eventCount); 652 } 653 654 /** 655 * @tc.name: ParseClkDisableEvent 656 * @tc.desc: Parse a clk_Disable event in htrace format 657 * @tc.type: FUNC 658 */ 659 HWTEST_F(HtraceEventParserTest, ParseClkDisableEvent, TestSize.Level1) 660 { 661 TS_LOGI("test14-15"); 662 ClkDisableFormat *clkDisableEvent = new ClkDisableFormat(); 663 clkDisableEvent->set_name(THREAD_NAME_02); 664 665 TracePluginResult tracePacket; 666 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 667 ftraceCpuDetail->set_cpu(0); 668 ftraceCpuDetail->set_overwrite(0); 669 auto ftraceEvent = ftraceCpuDetail->add_event(); 670 671 ftraceEvent->set_timestamp(TIMESTAMP); 672 ftraceEvent->set_tgid(2); 673 ftraceEvent->set_comm(THREAD_NAME_02); 674 ftraceEvent->set_allocated_clk_disable_format(clkDisableEvent); 675 676 PbreaderDataSegment dataSeg; 677 dataSeg.clockId = TS_CLOCK_BOOTTIME; 678 std::string cpuDetailStrMsg = ""; 679 tracePacket.SerializeToString(&cpuDetailStrMsg); 680 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 681 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 682 dataSeg.seg->size()); 683 dataSeg.protoData = cpuDetailBytesView; 684 685 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 686 bool haveSplit = false; 687 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 688 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 689 htraceCpuDetailParser.FilterAllEvents(); 690 auto eventCount = 691 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_DISABLE, STAT_EVENT_RECEIVED); 692 EXPECT_TRUE(1 == eventCount); 693 } 694 695 /** 696 * @tc.name: ParseClkEnableEvent 697 * @tc.desc: Parse a clk_Enable event in htrace format 698 * @tc.type: FUNC 699 */ 700 HWTEST_F(HtraceEventParserTest, ParseClkEnableEvent, TestSize.Level1) 701 { 702 TS_LOGI("test14-16"); 703 ClkEnableFormat *clkEnableEvent = new ClkEnableFormat(); 704 clkEnableEvent->set_name(THREAD_NAME_02); 705 706 TracePluginResult tracePacket; 707 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 708 ftraceCpuDetail->set_cpu(0); 709 ftraceCpuDetail->set_overwrite(0); 710 auto ftraceEvent = ftraceCpuDetail->add_event(); 711 712 ftraceEvent->set_timestamp(TIMESTAMP); 713 ftraceEvent->set_tgid(2); 714 ftraceEvent->set_comm(THREAD_NAME_02); 715 ftraceEvent->set_allocated_clk_enable_format(clkEnableEvent); 716 717 PbreaderDataSegment dataSeg; 718 dataSeg.clockId = TS_CLOCK_BOOTTIME; 719 std::string cpuDetailStrMsg = ""; 720 tracePacket.SerializeToString(&cpuDetailStrMsg); 721 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 722 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 723 dataSeg.seg->size()); 724 dataSeg.protoData = cpuDetailBytesView; 725 726 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 727 bool haveSplit = false; 728 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 729 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 730 htraceCpuDetailParser.FilterAllEvents(); 731 auto eventCount = 732 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_ENABLE, STAT_EVENT_RECEIVED); 733 EXPECT_TRUE(1 == eventCount); 734 } 735 736 /** 737 * @tc.name: ParseClkSetRateEvent 738 * @tc.desc: Parse a clk_set_rate event in htrace format 739 * @tc.type: FUNC 740 */ 741 HWTEST_F(HtraceEventParserTest, ParseClkSetRateEvent, TestSize.Level1) 742 { 743 TS_LOGI("test14-17"); 744 ClkSetRateFormat *clkSetRateEvent = new ClkSetRateFormat(); 745 clkSetRateEvent->set_name(THREAD_NAME_02); 746 clkSetRateEvent->set_rate(1); 747 748 TracePluginResult tracePacket; 749 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 750 ftraceCpuDetail->set_cpu(0); 751 ftraceCpuDetail->set_overwrite(0); 752 auto ftraceEvent = ftraceCpuDetail->add_event(); 753 754 ftraceEvent->set_timestamp(TIMESTAMP); 755 ftraceEvent->set_tgid(2); 756 ftraceEvent->set_comm(THREAD_NAME_02); 757 ftraceEvent->set_allocated_clk_set_rate_format(clkSetRateEvent); 758 759 PbreaderDataSegment dataSeg; 760 dataSeg.clockId = TS_CLOCK_BOOTTIME; 761 std::string cpuDetailStrMsg = ""; 762 tracePacket.SerializeToString(&cpuDetailStrMsg); 763 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 764 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 765 dataSeg.seg->size()); 766 dataSeg.protoData = cpuDetailBytesView; 767 768 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 769 bool haveSplit = false; 770 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 771 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 772 htraceCpuDetailParser.FilterAllEvents(); 773 auto eventCount = 774 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_CLK_SET_RATE, STAT_EVENT_RECEIVED); 775 EXPECT_TRUE(1 == eventCount); 776 } 777 778 /** 779 * @tc.name: ParseSysEnterEvent 780 * @tc.desc: Parse a sysEnter event in htrace format 781 * @tc.type: FUNC 782 */ 783 HWTEST_F(HtraceEventParserTest, ParseSysEnterEvent, TestSize.Level1) 784 { 785 TS_LOGI("test14-18"); 786 SysEnterFormat *sysEnterEvent = new SysEnterFormat(); 787 sysEnterEvent->set_id(1); 788 789 TracePluginResult tracePacket; 790 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 791 ftraceCpuDetail->set_cpu(0); 792 ftraceCpuDetail->set_overwrite(0); 793 auto ftraceEvent = ftraceCpuDetail->add_event(); 794 795 ftraceEvent->set_timestamp(TIMESTAMP); 796 ftraceEvent->set_tgid(2); 797 ftraceEvent->set_comm(THREAD_NAME_02); 798 ftraceEvent->set_allocated_sys_enter_format(sysEnterEvent); 799 800 PbreaderDataSegment dataSeg; 801 dataSeg.clockId = TS_CLOCK_BOOTTIME; 802 std::string cpuDetailStrMsg = ""; 803 tracePacket.SerializeToString(&cpuDetailStrMsg); 804 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 805 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 806 dataSeg.seg->size()); 807 dataSeg.protoData = cpuDetailBytesView; 808 809 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 810 bool haveSplit = false; 811 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 812 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 813 htraceCpuDetailParser.FilterAllEvents(); 814 auto eventCount = 815 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_ENTRY, STAT_EVENT_RECEIVED); 816 EXPECT_TRUE(1 == eventCount); 817 } 818 /** 819 * @tc.name: ParseSystemExitEvent 820 * @tc.desc: Parse a system_exit event in htrace format 821 * @tc.type: FUNC 822 */ 823 HWTEST_F(HtraceEventParserTest, ParseSystemExitEvent, TestSize.Level1) 824 { 825 TS_LOGI("test14-19"); 826 SysExitFormat *sysExitEvent = new SysExitFormat(); 827 sysExitEvent->set_id(1); 828 sysExitEvent->set_ret(1); 829 830 TracePluginResult tracePacket; 831 FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 832 ftraceCpuDetail->set_cpu(0); 833 ftraceCpuDetail->set_overwrite(0); 834 auto ftraceEvent = ftraceCpuDetail->add_event(); 835 836 ftraceEvent->set_timestamp(TIMESTAMP); 837 ftraceEvent->set_tgid(2); 838 ftraceEvent->set_comm(THREAD_NAME_02); 839 ftraceEvent->set_allocated_sys_exit_format(sysExitEvent); 840 841 PbreaderDataSegment dataSeg; 842 dataSeg.clockId = TS_CLOCK_BOOTTIME; 843 std::string cpuDetailStrMsg = ""; 844 tracePacket.SerializeToString(&cpuDetailStrMsg); 845 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 846 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 847 dataSeg.seg->size()); 848 dataSeg.protoData = cpuDetailBytesView; 849 850 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 851 bool haveSplit = false; 852 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 853 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 854 htraceCpuDetailParser.FilterAllEvents(); 855 auto eventCount = 856 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_EVENT_SYS_EXIT, STAT_EVENT_RECEIVED); 857 EXPECT_TRUE(1 == eventCount); 858 } 859 } // namespace TraceStreamer 860 } // namespace SysTuning 861