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