1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 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 "filter_filter.h" 20 #include "measure_filter.h" 21 #include "trace_streamer_selector.h" 22 23 using namespace testing::ext; 24 using namespace SysTuning::TraceStreamer; 25 namespace SysTuning { 26 namespace TraceStreamer { 27 constexpr int CPU_ID_0 = 0; 28 constexpr int CPU_ID_1 = 1; 29 constexpr std::string_view CPU_TYPE_0 = "cpu_idle"; 30 constexpr std::string_view CPU_TYPE_1 = "cpu_frequency"; 31 constexpr int INTERNAL_THREAD_ID_0 = 1; 32 constexpr int INTERNAL_THREAD_ID_1 = 2; 33 constexpr int INTERNAL_PROCESS_ID_0 = 1; 34 constexpr int INTERNAL_PROCESS_ID_1 = 2; 35 constexpr std::string_view TASK_NAME_0 = "softbus_server"; 36 constexpr std::string_view TASK_NAME_1 = "hiprofilerd"; 37 38 class MeasureFilterTest : public ::testing::Test { 39 public: SetUp()40 void SetUp() 41 { 42 stream_.InitFilter(); 43 } 44 TearDown()45 void TearDown() {} 46 47 public: 48 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 49 }; 50 51 /** 52 * @tc.name: ThreadMeasureFilter 53 * @tc.desc: Test whether the GetOrCreateFilterId interface generated filterid and threadmeasure Info is correct 54 * @tc.type: FUNC 55 */ 56 HWTEST_F(MeasureFilterTest, ThreadMeasureFilter, TestSize.Level1) 57 { 58 TS_LOGI("test23-1"); 59 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 60 uint32_t filterId = 61 stream_.streamFilters_->threadMeasureFilter_->GetOrCreateFilterId(INTERNAL_THREAD_ID_0, nameIndex0); 62 EXPECT_TRUE(filterId == 0); 63 64 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 65 filterId = stream_.streamFilters_->threadMeasureFilter_->GetOrCreateFilterId(INTERNAL_THREAD_ID_1, nameIndex1); 66 EXPECT_TRUE(filterId == 1); 67 68 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 69 EXPECT_TRUE(filterTable->Size() == 2); 70 71 ThreadMeasureFilter* threadMeasureTable = stream_.traceDataCache_->GetThreadMeasureFilterData(); 72 EXPECT_TRUE(threadMeasureTable->Size() == 2); 73 EXPECT_TRUE(threadMeasureTable->FilterIdData()[0] == 0); 74 EXPECT_TRUE(threadMeasureTable->FilterIdData()[1] == 1); 75 EXPECT_TRUE(threadMeasureTable->InternalTidData()[0] == INTERNAL_THREAD_ID_0); 76 EXPECT_TRUE(threadMeasureTable->InternalTidData()[1] == INTERNAL_THREAD_ID_1); 77 } 78 79 /** 80 * @tc.name: ThreadFilter 81 * @tc.desc: Test whether the GetOrCreateFilterId interface generated filterid and thread Info is correct 82 * @tc.type: FUNC 83 */ 84 HWTEST_F(MeasureFilterTest, ThreadFilter, TestSize.Level1) 85 { 86 TS_LOGI("test23-2"); 87 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 88 uint32_t filterId = stream_.streamFilters_->threadFilter_->GetOrCreateFilterId(INTERNAL_THREAD_ID_0, nameIndex0); 89 EXPECT_TRUE(filterId == 0); 90 91 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 92 filterId = stream_.streamFilters_->threadFilter_->GetOrCreateFilterId(INTERNAL_THREAD_ID_1, nameIndex1); 93 EXPECT_TRUE(filterId == 1); 94 95 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 96 EXPECT_TRUE(filterTable->Size() == 2); 97 98 ThreadMeasureFilter* threadTable = stream_.traceDataCache_->GetThreadFilterData(); 99 EXPECT_TRUE(threadTable->Size() == 2); 100 EXPECT_TRUE(threadTable->FilterIdData()[0] == 0); 101 EXPECT_TRUE(threadTable->FilterIdData()[1] == 1); 102 EXPECT_TRUE(threadTable->InternalTidData()[0] == INTERNAL_THREAD_ID_0); 103 EXPECT_TRUE(threadTable->InternalTidData()[1] == INTERNAL_THREAD_ID_1); 104 } 105 106 /** 107 * @tc.name: CpuFilter 108 * @tc.desc: Test GetOrCreateFilterId interface of class CpuFilter 109 * @tc.type: FUNC 110 */ 111 HWTEST_F(MeasureFilterTest, CpuFilter, TestSize.Level1) 112 { 113 TS_LOGI("test23-3"); 114 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(CPU_TYPE_0); 115 uint32_t filterId = stream_.streamFilters_->cpuMeasureFilter_->GetOrCreateFilterId(CPU_ID_0, nameIndex_0); 116 EXPECT_TRUE(filterId == 0); 117 118 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(CPU_TYPE_1); 119 filterId = stream_.streamFilters_->cpuMeasureFilter_->GetOrCreateFilterId(CPU_ID_1, nameIndex_1); 120 EXPECT_TRUE(filterId == 1); 121 122 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 123 EXPECT_TRUE(filterTable->Size() == 2); 124 125 CpuMeasureFilter* cpuMeasureTable = stream_.traceDataCache_->GetCpuMeasuresData(); 126 EXPECT_TRUE(cpuMeasureTable->Size() == 2); 127 EXPECT_TRUE(cpuMeasureTable->IdsData()[0] == 0); 128 EXPECT_TRUE(cpuMeasureTable->IdsData()[1] == 1); 129 EXPECT_TRUE(cpuMeasureTable->CpuData()[0] == CPU_ID_0); 130 EXPECT_TRUE(cpuMeasureTable->CpuData()[1] == CPU_ID_1); 131 } 132 133 /** 134 * @tc.name: ProcessFilter 135 * @tc.desc: Test GetOrCreateFilterId interface of class ProcessFilter 136 * @tc.type: FUNC 137 */ 138 HWTEST_F(MeasureFilterTest, ProcessFilter, TestSize.Level1) 139 { 140 TS_LOGI("test23-4"); 141 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 142 uint32_t filterId = 143 stream_.streamFilters_->processFilterFilter_->GetOrCreateFilterId(INTERNAL_PROCESS_ID_0, nameIndex_0); 144 EXPECT_TRUE(filterId == 0); 145 146 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 147 filterId = stream_.streamFilters_->processFilterFilter_->GetOrCreateFilterId(INTERNAL_PROCESS_ID_1, nameIndex_1); 148 EXPECT_TRUE(filterId == 1); 149 150 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 151 EXPECT_TRUE(filterTable->Size() == 2); 152 153 ProcessMeasureFilter* processFilterTable = stream_.traceDataCache_->GetProcessFilterData(); 154 EXPECT_TRUE(processFilterTable->Size() == 2); 155 } 156 157 /** 158 * @tc.name: ClockRateFilter 159 * @tc.desc: Test GetOrCreateFilterId interface of class ClockRateFilter 160 * @tc.type: FUNC 161 */ 162 HWTEST_F(MeasureFilterTest, ClockRateFilter, TestSize.Level1) 163 { 164 TS_LOGI("test23-5"); 165 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 166 uint32_t filterId = stream_.streamFilters_->clockRateFilter_->GetOrCreateFilterId(CPU_ID_0, nameIndex_0); 167 EXPECT_TRUE(filterId == 0); 168 169 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 170 filterId = stream_.streamFilters_->clockRateFilter_->GetOrCreateFilterId(CPU_ID_1, nameIndex_1); 171 EXPECT_TRUE(filterId == 1); 172 173 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 174 EXPECT_TRUE(filterTable->Size() == 2); 175 176 ClockEventData* clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 177 EXPECT_TRUE(clockEventTable->Size() == 2); 178 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 179 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 180 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 181 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 182 } 183 184 /** 185 * @tc.name: ClockEnableFilter 186 * @tc.desc: Test GetOrCreateFilterId interface of class ClockEnableFilter 187 * @tc.type: FUNC 188 */ 189 HWTEST_F(MeasureFilterTest, ClockEnableFilter, TestSize.Level1) 190 { 191 TS_LOGI("test23-6"); 192 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 193 uint32_t filterId = stream_.streamFilters_->clockEnableFilter_->GetOrCreateFilterId(CPU_ID_0, nameIndex_0); 194 EXPECT_TRUE(filterId == 0); 195 196 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 197 filterId = stream_.streamFilters_->clockEnableFilter_->GetOrCreateFilterId(CPU_ID_1, nameIndex_1); 198 EXPECT_TRUE(filterId == 1); 199 200 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 201 EXPECT_TRUE(filterTable->Size() == 2); 202 203 ClockEventData* clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 204 EXPECT_TRUE(clockEventTable->Size() == 2); 205 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 206 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 207 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 208 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 209 } 210 211 /** 212 * @tc.name: ClockDisableFilter 213 * @tc.desc: Test GetOrCreateFilterId interface of class ClockDisableFilter 214 * @tc.type: FUNC 215 */ 216 HWTEST_F(MeasureFilterTest, ClockDisableFilter, TestSize.Level1) 217 { 218 TS_LOGI("test23-7"); 219 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 220 uint32_t filterId = stream_.streamFilters_->clockDisableFilter_->GetOrCreateFilterId(CPU_ID_0, nameIndex_0); 221 EXPECT_TRUE(filterId == 0); 222 223 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 224 filterId = stream_.streamFilters_->clockDisableFilter_->GetOrCreateFilterId(CPU_ID_1, nameIndex_1); 225 EXPECT_TRUE(filterId == 1); 226 227 Filter* filterTable = stream_.traceDataCache_->GetFilterData(); 228 EXPECT_TRUE(filterTable->Size() == 2); 229 230 ClockEventData* clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 231 EXPECT_TRUE(clockEventTable->Size() == 2); 232 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 233 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 234 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 235 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 236 } 237 238 /** 239 * @tc.name: MeasureFilterTest 240 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(MeasureFilterTest, MeasureFilterTest, TestSize.Level1) 244 { 245 TS_LOGI("test23-8"); 246 uint64_t itid = 1; 247 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 248 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 249 auto threadMeasureFilter = stream_.streamFilters_->processMeasureFilter_.get(); 250 threadMeasureFilter->AppendNewMeasureData(itid, nameIndex0, 168758682476000, 1200); 251 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 1); 252 } 253 254 /** 255 * @tc.name: MeasureFilterAddMultiMemToSingleThread 256 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest, Adding multiple memory information tests to 257 * the same thread 258 * @tc.type: FUNC 259 */ 260 HWTEST_F(MeasureFilterTest, MeasureFilterAddMultiMemToSingleThread, TestSize.Level1) 261 { 262 TS_LOGI("test23-9"); 263 uint64_t itid = 1; 264 auto threadMeasureFilter = stream_.streamFilters_->processMeasureFilter_.get(); 265 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 266 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 267 threadMeasureFilter->AppendNewMeasureData(itid, nameIndex0, 168758682476000, 1200); 268 const std::string_view MEASURE_ITEM_NAME2 = "mem_vm"; 269 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME2); 270 threadMeasureFilter->AppendNewMeasureData(itid, nameIndex1, 168758682477000, 9200); 271 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 2); 272 } 273 274 /** 275 * @tc.name: MeasureFilterAddMultiMemToMultiThread 276 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest, Adding multiple memory information to multi 277 * thread 278 * @tc.type: FUNC 279 */ 280 HWTEST_F(MeasureFilterTest, MeasureFilterAddMultiMemToMultiThread, TestSize.Level1) 281 { 282 TS_LOGI("test23-10"); 283 uint64_t itid = 1; 284 uint64_t itid2 = 2; 285 auto threadMeasureFilter = stream_.streamFilters_->processMeasureFilter_.get(); 286 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 287 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 288 threadMeasureFilter->AppendNewMeasureData(itid, nameIndex0, 168758682476000, 1200); 289 const std::string_view MEASURE_ITEM_NAME2 = "mem_vm"; 290 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME2); 291 threadMeasureFilter->AppendNewMeasureData(itid2, nameIndex1, 168758682477000, 9200); 292 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 2); 293 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().ValuesData()[0] == 1200); 294 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().ValuesData()[1] == 9200); 295 } 296 297 /** 298 * @tc.name: MeasureFilterAddPerfclLfMux 299 * @tc.desc: Add perfcl_ lf_mux status test 300 * @tc.type: FUNC 301 */ 302 HWTEST_F(MeasureFilterTest, MeasureFilterAddPerfclLfMux, TestSize.Level1) 303 { 304 TS_LOGI("test23-11"); 305 uint64_t cpuId = 1; 306 int64_t state = 0; 307 auto threadMeasureFilter = stream_.streamFilters_->clockDisableFilter_.get(); 308 const std::string_view MEASURE_ITEM_NAME = "perfcl_lf_mux"; 309 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 310 threadMeasureFilter->AppendNewMeasureData(cpuId, nameIndex0, 168758682476000, state); 311 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().Size() == 1); 312 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0] == state); 313 } 314 315 /** 316 * @tc.name: MeasureFilterAddPerfclPll 317 * @tc.desc: Add perfcl_pll status test 318 * @tc.type: FUNC 319 */ 320 HWTEST_F(MeasureFilterTest, MeasureFilterAddPerfclPll, TestSize.Level1) 321 { 322 TS_LOGI("test23-12"); 323 uint64_t cpuId = 1; 324 int64_t state = 1747200000; 325 auto threadMeasureFilter = stream_.streamFilters_->clockRateFilter_.get(); 326 const std::string_view MEASURE_ITEM_NAME = "perfcl_pll"; 327 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 328 threadMeasureFilter->AppendNewMeasureData(cpuId, nameIndex0, 168758682476000, state); 329 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().Size() == 1); 330 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0] == state); 331 } 332 } // namespace TraceStreamer 333 } // namespace SysTuning 334