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 "htrace_cpu_detail_parser.h" 20 #include "power.pb.h" 21 #include "stat_filter.h" 22 #include "trace_streamer_selector.h" 23 #include "trace_plugin_result.pb.h" 24 #include "trace_plugin_result.pbreader.h" 25 26 using namespace testing::ext; 27 using namespace SysTuning::TraceStreamer; 28 29 namespace SysTuning { 30 namespace TraceStreamer { 31 class HtraceCpuDetailParserTest : public ::testing::Test { 32 public: SetUp()33 void SetUp() 34 { 35 stream_.InitFilter(); 36 } 37 TearDown() const38 void TearDown() const {} 39 40 public: 41 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 42 }; 43 44 /** 45 * @tc.name: ParseCpudetaulNoEvents 46 * @tc.desc: Parse a cpudetaul with no events 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(HtraceCpuDetailParserTest, ParseCpudetaulNoEvents, TestSize.Level1) 50 { 51 TS_LOGI("test12-1"); 52 TracePluginResult tracePacket; 53 FtraceCpuDetailMsg *cpuDetail = tracePacket.add_ftrace_cpu_detail(); 54 55 PbreaderDataSegment dataSeg; 56 dataSeg.clockId = TS_CLOCK_REALTIME; 57 std::string cpuDetailStrMsg = ""; 58 tracePacket.SerializeToString(&cpuDetailStrMsg); 59 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 60 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 61 dataSeg.seg->size()); 62 dataSeg.protoData = cpuDetailBytesView; 63 64 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 65 bool haveSplit = false; 66 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 67 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 68 htraceCpuDetailParser.FilterAllEvents(); 69 EXPECT_EQ(tracePacket.ftrace_cpu_detail_size(), 1); 70 EXPECT_EQ(cpuDetail->event_size(), 0); 71 } 72 /** 73 * @tc.name: ParseHtraceWithoutCpuDetailData 74 * @tc.desc: Parse a cpu that does not contain any cpudetail 75 * @tc.type: FUNC 76 */ 77 HWTEST_F(HtraceCpuDetailParserTest, ParseHtraceWithoutCpuDetailData, TestSize.Level1) 78 { 79 TS_LOGI("test12-2"); 80 TracePluginResult tracePacket; 81 FtraceCpuDetailMsg *cpuDetail = tracePacket.add_ftrace_cpu_detail(); 82 auto event = cpuDetail->add_event(); 83 84 PbreaderDataSegment dataSeg; 85 dataSeg.clockId = TS_CLOCK_REALTIME; 86 87 std::string cpuDetailStrMsg = ""; 88 tracePacket.SerializeToString(&cpuDetailStrMsg); 89 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 90 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 91 dataSeg.seg->size()); 92 dataSeg.protoData = cpuDetailBytesView; 93 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 94 bool haveSplit = false; 95 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 96 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 97 htraceCpuDetailParser.FilterAllEvents(); 98 EXPECT_EQ(tracePacket.ftrace_cpu_detail_size(), 1); 99 EXPECT_EQ(cpuDetail->event_size(), 1); 100 } 101 /** 102 * @tc.name: ParseHtraceCpuDetailData 103 * @tc.desc: Parse a cpudetail data 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(HtraceCpuDetailParserTest, ParseHtraceCpuDetailData, TestSize.Level1) 107 { 108 TS_LOGI("test12-3"); 109 TracePluginResult tracePacket; 110 FtraceCpuDetailMsg *cpuDetail = tracePacket.add_ftrace_cpu_detail(); 111 auto event = cpuDetail->add_event(); 112 cpuDetail->set_cpu(1); 113 event->set_timestamp(1501983446213000000); 114 event->set_tgid(1); 115 CpuFrequencyFormat *freq = new CpuFrequencyFormat(); 116 freq->set_cpu_id(1); 117 freq->set_state(1500); 118 event->set_allocated_cpu_frequency_format(freq); 119 120 PbreaderDataSegment dataSeg; 121 dataSeg.clockId = TS_CLOCK_REALTIME; 122 123 std::string cpuDetailStrMsg = ""; 124 tracePacket.SerializeToString(&cpuDetailStrMsg); 125 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 126 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 127 dataSeg.seg->size()); 128 dataSeg.protoData = cpuDetailBytesView; 129 130 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 131 bool haveSplit = false; 132 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 133 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 134 htraceCpuDetailParser.FilterAllEvents(); 135 EXPECT_EQ(tracePacket.ftrace_cpu_detail_size(), 1); 136 EXPECT_EQ(cpuDetail->event_size(), 1); 137 EXPECT_EQ(stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0], 1500); 138 } 139 /** 140 * @tc.name: ParseMultipleCpuDetailData 141 * @tc.desc: Parse multiple cpudetail data 142 * @tc.type: FUNC 143 */ 144 HWTEST_F(HtraceCpuDetailParserTest, ParseMultipleCpuDetailData, TestSize.Level1) 145 { 146 TS_LOGI("test12-4"); 147 TracePluginResult tracePacket; 148 FtraceCpuDetailMsg *cpuDetail = tracePacket.add_ftrace_cpu_detail(); 149 auto event = cpuDetail->add_event(); 150 cpuDetail->set_cpu(1); 151 event->set_timestamp(1501983446213000000); 152 event->set_tgid(1); 153 CpuFrequencyFormat *freq0 = new CpuFrequencyFormat(); 154 freq0->set_cpu_id(1); 155 freq0->set_state(1500); 156 event->set_allocated_cpu_frequency_format(freq0); 157 158 cpuDetail = tracePacket.add_ftrace_cpu_detail(); 159 event = cpuDetail->add_event(); 160 cpuDetail->set_cpu(1); 161 event->set_timestamp(1501983446213000000); 162 event->set_tgid(1); 163 CpuFrequencyFormat *freq1 = new CpuFrequencyFormat(); 164 freq1->set_cpu_id(2); 165 freq1->set_state(3000); 166 event->set_allocated_cpu_frequency_format(freq1); 167 168 PbreaderDataSegment dataSeg; 169 dataSeg.clockId = TS_CLOCK_REALTIME; 170 171 std::string cpuDetailStrMsg = ""; 172 tracePacket.SerializeToString(&cpuDetailStrMsg); 173 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 174 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()), 175 dataSeg.seg->size()); 176 dataSeg.protoData = cpuDetailBytesView; 177 178 HtraceCpuDetailParser htraceCpuDetailParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 179 bool haveSplit = false; 180 ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData); 181 htraceCpuDetailParser.Parse(dataSeg, tracePluginResult, haveSplit); 182 htraceCpuDetailParser.FilterAllEvents(); 183 EXPECT_EQ(tracePacket.ftrace_cpu_detail_size(), 2); 184 EXPECT_EQ(cpuDetail->event_size(), 1); 185 auto measureData = stream_.traceDataCache_->GetConstMeasureData(); 186 EXPECT_EQ(measureData.ValuesData()[0], 1500); 187 EXPECT_EQ(measureData.ValuesData()[1], 3000); 188 } 189 } // namespace TraceStreamer 190 } // namespace SysTuning 191