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 "args_filter.h" 20 #include "irq_filter.h" 21 #include "slice_filter.h" 22 #include "stat_filter.h" 23 #include "ts_common.h" 24 25 using namespace testing::ext; 26 using namespace SysTuning::TraceStreamer; 27 namespace SysTuning { 28 namespace TraceStreamer { 29 class IrqFilterTest : public ::testing::Test { 30 public: SetUp()31 void SetUp() 32 { 33 streamFilters_.argsFilter_ = std::make_unique<ArgsFilter>(&traceDataCache_, &streamFilters_); 34 streamFilters_.irqFilter_ = std::make_unique<IrqFilter>(&traceDataCache_, &streamFilters_); 35 streamFilters_.sliceFilter_ = std::make_unique<SliceFilter>(&traceDataCache_, &streamFilters_); 36 streamFilters_.statFilter_ = std::make_unique<StatFilter>(&traceDataCache_, &streamFilters_); 37 streamFilters_.statFilter_ = std::make_unique<StatFilter>(&traceDataCache_, &streamFilters_); 38 } 39 TearDown()40 void TearDown() {} 41 42 public: 43 TraceStreamerFilters streamFilters_; 44 TraceDataCache traceDataCache_; 45 }; 46 47 /** 48 * @tc.name: IrqHandlerEntryTest 49 * @tc.desc: IrqHandlerEntry Normal TEST 50 * @tc.type: FUNC 51 */ 52 HWTEST_F(IrqFilterTest, IrqHandlerEntryTest, TestSize.Level1) 53 { 54 TS_LOGI("test22-1"); 55 int64_t ts1 = 100; 56 uint32_t cpu1 = 1; 57 DataIndex nameId1 = 1; 58 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 59 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 60 } 61 62 /** 63 * @tc.name: IrqHandlerEntryTestNotMatch 64 * @tc.desc: Test two interrupts, only start, no end 65 * @tc.type: FUNC 66 */ 67 HWTEST_F(IrqFilterTest, IrqHandlerEntryTestNotMatch, TestSize.Level1) 68 { 69 TS_LOGI("test22-2"); 70 int64_t ts1 = 120; 71 uint32_t cpu1 = 1; 72 DataIndex nameId1 = 1; 73 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 74 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 75 ts1 = 110; 76 uint32_t irqRet = 1; 77 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, irqRet); // IrqHandlerEntry 78 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 79 // TRACE_EVENT_IRQ_HANDLER_ENTRY STAT_EVENT_DATA_LOST 80 auto eventCount = 81 traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_DATA_LOST); 82 EXPECT_TRUE(1 == eventCount); 83 } 84 85 /** 86 * @tc.name: IrqHandlerExitTestEmpty 87 * @tc.desc:Interrupt only ends, not starts 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(IrqFilterTest, IrqHandlerExitTestEmpty, TestSize.Level1) 91 { 92 TS_LOGI("test22-3"); 93 int64_t ts1 = 100; 94 uint32_t cpu1 = 1; 95 uint32_t ret = 1; // 1 for handled, else for unhandled 96 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret, ret); // IrqHandlerExit 97 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 0); 98 // TRACE_EVENT_IRQ_HANDLER_EXIT STAT_EVENT_NOTMATCH 99 auto eventCount = traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_NOTMATCH); 100 EXPECT_TRUE(1 == eventCount); 101 } 102 103 /** 104 * @tc.name: IrqHandlerEnterAndExitTest 105 * @tc.desc: Interrupt normal start and end 106 * @tc.type: FUNC 107 */ 108 HWTEST_F(IrqFilterTest, IrqHandlerEnterAndExitTest, TestSize.Level1) 109 { 110 TS_LOGI("test22-4"); 111 int64_t ts1 = 100; 112 uint32_t cpu1 = 1; 113 DataIndex nameId1 = 1; 114 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 115 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 116 uint32_t irqRet = 1; // 1 for handled, else for unhandled 117 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, irqRet, irqRet); // IrqHandlerExit 118 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 119 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 120 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 121 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().Size() == 2); 122 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().values_[0] == 123 static_cast<int64_t>(streamFilters_.irqFilter_->irqHandled_)); 124 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().names_[0] == streamFilters_.irqFilter_->irqRet_); 125 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().argset_[0] == 0); 126 } 127 128 /** 129 * @tc.name: IrqHandlerDoubleEnterAndExitTest 130 * @tc.desc: Interrupt normal test, 2 interrupts and exits 131 * @tc.type: FUNC 132 */ 133 HWTEST_F(IrqFilterTest, IrqHandlerDoubleEnterAndExitTest, TestSize.Level1) 134 { 135 TS_LOGI("test22-5"); 136 int64_t ts1 = 100; 137 uint32_t cpu1 = 1; 138 DataIndex nameId1 = 1; 139 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 140 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 141 uint32_t ret = 1; // 1 for handled, else for unhandled 142 cpu1 = 2; 143 ts1 = 150; 144 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret, ret); // IrqHandlerExit 145 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 146 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_NOTMATCH) == 1); 147 cpu1 = 1; 148 ts1 = 200; 149 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret, ret); // IrqHandlerExit 150 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 151 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 152 } 153 154 /** 155 * @tc.name: IrqHandlerTripleEnterAndExitTest 156 * @tc.desc: Interrupt normal test, 3 interrupts and exits 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(IrqFilterTest, IrqHandlerTripleEnterAndExitTest, TestSize.Level1) 160 { 161 TS_LOGI("test22-6"); 162 int64_t ts1 = 100; 163 uint32_t cpu1 = 1; 164 DataIndex nameId1 = 1; 165 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); // IrqHandlerEntry 166 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 167 uint32_t ret = 1; // 1 for handled, else for unhandled 168 ts1 = 150; 169 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret, ret); // IrqHandlerExit 170 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 171 // check args 172 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 173 174 ts1 = 200; 175 cpu1 = 1; 176 nameId1 = 1; 177 streamFilters_.irqFilter_->IrqHandlerEntry(ts1, cpu1, nameId1); 178 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 179 ret = 1; // 1 for handled, else for unhandled 180 ts1 = 250; 181 streamFilters_.irqFilter_->IrqHandlerExit(ts1, cpu1, ret, ret); 182 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 183 // check args 184 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[1] == 1); 185 } 186 187 /** 188 * @tc.name: SoftIrqEntryTest 189 * @tc.desc: Soft interrupt normal test 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(IrqFilterTest, SoftIrqEntryTest, TestSize.Level1) 193 { 194 TS_LOGI("test22-7"); 195 int64_t ts1 = 100; 196 uint32_t cpu1 = 1; 197 uint32_t vec = 1; 198 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 199 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 200 } 201 202 /** 203 * @tc.name: SoftIrqEntryNotMatch 204 * @tc.desc: The soft interrupts do not match. The two interrupts have only the beginning and no end 205 * @tc.type: FUNC 206 */ 207 HWTEST_F(IrqFilterTest, SoftIrqEntryNotMatch, TestSize.Level1) 208 { 209 TS_LOGI("test22-8"); 210 int64_t ts1 = 100; 211 uint32_t cpu1 = 1; 212 uint32_t vec = 1; 213 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); // SoftIrqEntry 214 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 215 ts1 = 150; 216 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); // SoftIrqEntry 217 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 2); 218 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_DATA_LOST) == 1); 219 } 220 221 /** 222 * @tc.name: SoftIrqExitEmptyTest 223 * @tc.desc: The soft interrupt only ends without starting 224 * @tc.type: FUNC 225 */ 226 HWTEST_F(IrqFilterTest, SoftIrqExitEmptyTest, TestSize.Level1) 227 { 228 TS_LOGI("test22-9"); 229 int64_t ts1 = 100; 230 uint32_t cpu1 = 1; 231 uint32_t vec = 1; 232 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 233 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 0); 234 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 235 } 236 237 /** 238 * @tc.name: SoftIrqTest 239 * @tc.desc: The soft interrupt normal test 240 * @tc.type: FUNC 241 */ 242 HWTEST_F(IrqFilterTest, SoftIrqTest, TestSize.Level1) 243 { 244 TS_LOGI("test22-10"); 245 int64_t ts1 = 100; 246 uint32_t cpu1 = 1; 247 uint32_t vec = 1; 248 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 249 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 250 ts1 = 150; 251 uint32_t irqRet = 1; 252 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, irqRet); 253 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 254 EXPECT_TRUE(traceDataCache_.GetConstIrqData().ArgSetIdsData()[0] == 0); 255 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().Size() == 2); 256 printf("%ld\n", traceDataCache_.GetConstArgSetData().values_[0]); 257 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().values_[0] == 258 static_cast<int64_t>(streamFilters_.irqFilter_->irqActionNameIds_[irqRet])); 259 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().names_[0] == streamFilters_.irqFilter_->irqRet_); 260 EXPECT_TRUE(traceDataCache_.GetConstArgSetData().argset_[0] == 0); 261 } 262 263 /** 264 * @tc.name: SoftIrqTestWithIrqEntryAndExit 265 * @tc.desc: The soft interrupt normal test 266 * @tc.type: FUNC 267 */ 268 HWTEST_F(IrqFilterTest, SoftIrqTestWithIrqEntryAndExit, TestSize.Level1) 269 { 270 TS_LOGI("test22-11"); 271 int64_t ts1 = 100; 272 uint32_t cpu1 = 1; 273 uint32_t vec = 1; 274 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 275 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 276 ts1 = 150; 277 cpu1 = 2; 278 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 279 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 280 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 281 } 282 283 /** 284 * @tc.name: SoftIrqTestOneEntryTwoNotMatchExit 285 * @tc.desc: The soft interrupt test with onece entry and twice Not Match exit 286 * @tc.type: FUNC 287 */ 288 HWTEST_F(IrqFilterTest, SoftIrqTestOneEntryTwoNotMatchExit, TestSize.Level1) 289 { 290 TS_LOGI("test22-12"); 291 int64_t ts1 = 100; 292 uint32_t cpu1 = 1; 293 uint32_t vec = 1; 294 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 295 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 296 ts1 = 150; 297 cpu1 = 2; 298 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 299 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 300 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 301 ts1 = 200; 302 cpu1 = 3; 303 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 304 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 305 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 2); 306 } 307 308 /** 309 * @tc.name: SoftIrqTestWithSingleNotMatchExit 310 * @tc.desc: The soft interrupt test with single not Match Exit 311 * @tc.type: FUNC 312 */ 313 HWTEST_F(IrqFilterTest, SoftIrqTestWithSingleNotMatchExit, TestSize.Level1) 314 { 315 TS_LOGI("test22-13"); 316 int64_t ts1 = 100; 317 uint32_t cpu1 = 1; 318 uint32_t vec = 1; 319 streamFilters_.irqFilter_->SoftIrqEntry(ts1, cpu1, vec); 320 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 321 ts1 = 150; 322 cpu1 = 2; 323 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 324 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 325 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 326 ts1 = 200; 327 cpu1 = 1; 328 streamFilters_.irqFilter_->SoftIrqExit(ts1, cpu1, vec); 329 EXPECT_TRUE(traceDataCache_.GetConstIrqData().Size() == 1); 330 EXPECT_TRUE(traceDataCache_.GetConstStatAndInfo().GetValue(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_LOST) == 1); 331 } 332 } // namespace TraceStreamer 333 } // namespace SysTuning 334