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 "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 int32_t CPU_ID_0 = 0; 28 constexpr int32_t 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 int32_t INTERNAL_THREAD_ID_0 = 1; 32 constexpr int32_t INTERNAL_THREAD_ID_1 = 2; 33 constexpr int32_t INTERNAL_PROCESS_ID_0 = 1; 34 constexpr int32_t 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: CpuFilter 53 * @tc.desc: Test GetOrCreateFilterId interface of class CpuFilter 54 * @tc.type: FUNC 55 */ 56 HWTEST_F(MeasureFilterTest, CpuFilter, TestSize.Level1) 57 { 58 TS_LOGI("test23-3"); 59 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(CPU_TYPE_0); 60 auto &measureFilter = stream_.streamFilters_->measureFilter_; 61 uint32_t filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CPU, CPU_ID_0, nameIndex_0); 62 EXPECT_TRUE(filterId == 0); 63 64 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(CPU_TYPE_1); 65 filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CPU, CPU_ID_1, nameIndex_1); 66 EXPECT_TRUE(filterId == 1); 67 68 Filter *filterTable = stream_.traceDataCache_->GetFilterData(); 69 EXPECT_TRUE(filterTable->Size() == 2); 70 71 CpuMeasureFilter *cpuMeasureTable = stream_.traceDataCache_->GetCpuMeasuresData(); 72 EXPECT_TRUE(cpuMeasureTable->Size() == 2); 73 EXPECT_TRUE(cpuMeasureTable->IdsData()[0] == 0); 74 EXPECT_TRUE(cpuMeasureTable->IdsData()[1] == 1); 75 EXPECT_TRUE(cpuMeasureTable->CpuData()[0] == CPU_ID_0); 76 EXPECT_TRUE(cpuMeasureTable->CpuData()[1] == CPU_ID_1); 77 } 78 79 /** 80 * @tc.name: ClockRateFilter 81 * @tc.desc: Test GetOrCreateFilterId interface of class ClockRateFilter 82 * @tc.type: FUNC 83 */ 84 HWTEST_F(MeasureFilterTest, ClockRateFilter, TestSize.Level1) 85 { 86 TS_LOGI("test23-5"); 87 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 88 auto &measureFilter = stream_.streamFilters_->measureFilter_; 89 uint32_t filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_RATE, CPU_ID_0, nameIndex_0); 90 EXPECT_TRUE(filterId == 0); 91 92 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 93 filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_RATE, CPU_ID_1, nameIndex_1); 94 EXPECT_TRUE(filterId == 1); 95 96 Filter *filterTable = stream_.traceDataCache_->GetFilterData(); 97 EXPECT_TRUE(filterTable->Size() == 2); 98 99 ClockEventData *clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 100 EXPECT_TRUE(clockEventTable->Size() == 2); 101 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 102 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 103 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 104 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 105 } 106 107 /** 108 * @tc.name: ClockEnableFilter 109 * @tc.desc: Test GetOrCreateFilterId interface of class ClockEnableFilter 110 * @tc.type: FUNC 111 */ 112 HWTEST_F(MeasureFilterTest, ClockEnableFilter, TestSize.Level1) 113 { 114 TS_LOGI("test23-6"); 115 auto &measureFilter = stream_.streamFilters_->measureFilter_; 116 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 117 uint32_t filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_ENABLE, CPU_ID_0, nameIndex_0); 118 EXPECT_TRUE(filterId == 0); 119 120 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 121 filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_ENABLE, CPU_ID_1, nameIndex_1); 122 EXPECT_TRUE(filterId == 1); 123 124 Filter *filterTable = stream_.traceDataCache_->GetFilterData(); 125 EXPECT_TRUE(filterTable->Size() == 2); 126 127 ClockEventData *clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 128 EXPECT_TRUE(clockEventTable->Size() == 2); 129 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 130 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 131 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 132 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 133 } 134 135 /** 136 * @tc.name: ClockDisableFilter 137 * @tc.desc: Test GetOrCreateFilterId interface of class ClockDisableFilter 138 * @tc.type: FUNC 139 */ 140 HWTEST_F(MeasureFilterTest, ClockDisableFilter, TestSize.Level1) 141 { 142 TS_LOGI("test23-7"); 143 auto &measureFilter = stream_.streamFilters_->measureFilter_; 144 auto nameIndex_0 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_0); 145 uint32_t filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_DISABLE, CPU_ID_0, nameIndex_0); 146 EXPECT_TRUE(filterId == 0); 147 148 auto nameIndex_1 = stream_.traceDataCache_->GetDataIndex(TASK_NAME_1); 149 filterId = measureFilter->GetOrCreateFilterId(EnumMeasureFilter::CLOCK_DISABLE, CPU_ID_1, nameIndex_1); 150 EXPECT_TRUE(filterId == 1); 151 152 Filter *filterTable = stream_.traceDataCache_->GetFilterData(); 153 EXPECT_TRUE(filterTable->Size() == 2); 154 155 ClockEventData *clockEventTable = stream_.traceDataCache_->GetClockEventFilterData(); 156 EXPECT_TRUE(clockEventTable->Size() == 2); 157 EXPECT_TRUE(clockEventTable->CpusData()[0] == CPU_ID_0); 158 EXPECT_TRUE(clockEventTable->CpusData()[1] == CPU_ID_1); 159 EXPECT_TRUE(clockEventTable->NamesData()[0] == nameIndex_0); 160 EXPECT_TRUE(clockEventTable->NamesData()[1] == nameIndex_1); 161 } 162 163 /** 164 * @tc.name: MeasureFilterTest 165 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest 166 * @tc.type: FUNC 167 */ 168 HWTEST_F(MeasureFilterTest, MeasureFilterTest, TestSize.Level1) 169 { 170 TS_LOGI("test23-8"); 171 uint64_t itid = 1; 172 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 173 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 174 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, itid, nameIndex0, 175 168758682476000, 1200); 176 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 1); 177 } 178 179 /** 180 * @tc.name: MeasureFilterAddMultiMemToSingleThread 181 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest, Adding multiple memory information tests to 182 * the same thread 183 * @tc.type: FUNC 184 */ 185 HWTEST_F(MeasureFilterTest, MeasureFilterAddMultiMemToSingleThread, TestSize.Level1) 186 { 187 TS_LOGI("test23-9"); 188 uint64_t itid = 1; 189 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 190 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 191 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, itid, nameIndex0, 192 168758682476000, 1200); 193 const std::string_view MEASURE_ITEM_NAME2 = "mem_vm"; 194 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME2); 195 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, itid, nameIndex1, 196 168758682477000, 9200); 197 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 2); 198 } 199 200 /** 201 * @tc.name: MeasureFilterAddMultiMemToMultiThread 202 * @tc.desc: Test GetOrCreateFilterId interface of class MeasureFilterTest, Adding multiple memory information to multi 203 * thread 204 * @tc.type: FUNC 205 */ 206 HWTEST_F(MeasureFilterTest, MeasureFilterAddMultiMemToMultiThread, TestSize.Level1) 207 { 208 TS_LOGI("test23-10"); 209 uint64_t itid = 1; 210 uint64_t itid2 = 2; 211 const std::string_view MEASURE_ITEM_NAME = "mem_rss"; 212 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 213 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, itid, nameIndex0, 214 168758682476000, 1200); 215 const std::string_view MEASURE_ITEM_NAME2 = "mem_vm"; 216 auto nameIndex1 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME2); 217 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, itid2, nameIndex1, 218 168758682477000, 9200); 219 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().Size() == 2); 220 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().ValuesData()[0] == 1200); 221 EXPECT_TRUE(stream_.traceDataCache_->GetConstProcessMeasureData().ValuesData()[1] == 9200); 222 } 223 224 /** 225 * @tc.name: MeasureFilterAddPerfclLfMux 226 * @tc.desc: Add perfcl_ lf_mux status test 227 * @tc.type: FUNC 228 */ 229 HWTEST_F(MeasureFilterTest, MeasureFilterAddPerfclLfMux, TestSize.Level1) 230 { 231 TS_LOGI("test23-11"); 232 uint64_t cpuId = 1; 233 int64_t state = 0; 234 const std::string_view MEASURE_ITEM_NAME = "perfcl_lf_mux"; 235 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 236 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, cpuId, nameIndex0, 237 168758682476000, state); 238 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().Size() == 1); 239 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0] == state); 240 } 241 242 /** 243 * @tc.name: MeasureFilterAddPerfclPll 244 * @tc.desc: Add perfcl_pll status test 245 * @tc.type: FUNC 246 */ 247 HWTEST_F(MeasureFilterTest, MeasureFilterAddPerfclPll, TestSize.Level1) 248 { 249 TS_LOGI("test23-12"); 250 uint64_t cpuId = 1; 251 int64_t state = 1747200000; 252 const std::string_view MEASURE_ITEM_NAME = "perfcl_pll"; 253 auto nameIndex0 = stream_.traceDataCache_->GetDataIndex(MEASURE_ITEM_NAME); 254 stream_.streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, cpuId, nameIndex0, 255 168758682476000, state); 256 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().Size() == 1); 257 EXPECT_TRUE(stream_.traceDataCache_->GetConstMeasureData().ValuesData()[0] == state); 258 } 259 } // namespace TraceStreamer 260 } // namespace SysTuning 261