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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <string> 20 #include <unordered_map> 21 22 #include "htrace_mem_parser.h" 23 #include "parser/common_types.h" 24 #include "trace_streamer_selector.h" 25 26 using namespace testing::ext; 27 using namespace SysTuning::TraceStreamer; 28 29 namespace SysTuning { 30 namespace TraceStreamer { 31 class HtraceSysMemParserTest : public ::testing::Test { 32 public: SetUp()33 void SetUp() 34 { 35 stream_.InitFilter(); 36 } 37 TearDown()38 void TearDown() 39 { 40 if (access(dbPath_.c_str(), F_OK) == 0) { 41 remove(dbPath_.c_str()); 42 } 43 } 44 45 public: 46 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 47 const std::string dbPath_ = "data/resource/out.db"; 48 }; 49 50 /** 51 * @tc.name: ParseSysMemParseInputEmpty 52 * @tc.desc: Kernel memory parsing test, input empty 53 * @tc.type: FUNC 54 */ 55 HWTEST_F(HtraceSysMemParserTest, ParseSysMemParseInputEmpty, TestSize.Level1) 56 { 57 TS_LOGI("test19-1"); 58 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 59 MemoryData tracePacket; 60 SysMeminfo* mem = tracePacket.add_meminfo(); 61 EXPECT_TRUE(mem != nullptr); 62 int size = tracePacket.meminfo_size(); 63 EXPECT_TRUE(size == 1); 64 mem->set_key(SysMeminfoType::PMEM_MEM_TOTAL); 65 uint64_t value = random(); 66 mem->set_value(value); 67 uint64_t timeStamp = 1616439852302; 68 BuiltinClocks clock = TS_CLOCK_REALTIME; 69 uint64_t zarm = 100; 70 tracePacket.set_zram(zarm); 71 72 memParser->Parse(tracePacket, timeStamp, clock); 73 stream_.traceDataCache_->ExportDatabase(dbPath_); 74 75 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 76 tracePacket.clear_meminfo(); 77 delete memParser; 78 79 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); 80 EXPECT_TRUE(1 == eventCount); 81 EXPECT_EQ(2, stream_.traceDataCache_->GetConstSysMeasureFilterData().Size()); 82 EXPECT_EQ(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[0], static_cast<int64_t>(value)); 83 } 84 85 /** 86 * @tc.name: ParseSysMemParseNormal 87 * @tc.desc: Kernel memory parsing test normal 88 * @tc.type: FUNC 89 */ 90 HWTEST_F(HtraceSysMemParserTest, ParseSysMemParseNormal, TestSize.Level1) 91 { 92 TS_LOGI("test19-2"); 93 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 94 95 MemoryData tracePacket; 96 SysMeminfo* mem = tracePacket.add_meminfo(); 97 EXPECT_TRUE(mem != nullptr); 98 int size = tracePacket.meminfo_size(); 99 EXPECT_TRUE(size == 1); 100 mem->set_key(SysMeminfoType::PMEM_MEM_TOTAL); 101 uint64_t value = random(); 102 mem->set_value(value); 103 104 mem = tracePacket.add_meminfo(); 105 EXPECT_TRUE(mem != nullptr); 106 size = tracePacket.meminfo_size(); 107 EXPECT_TRUE(size == 2); 108 mem->set_key(SysMeminfoType::PMEM_MEM_FREE); 109 uint64_t value2 = random(); 110 mem->set_value(value2); 111 uint64_t zarm = 100; 112 tracePacket.set_zram(zarm); 113 114 uint64_t timeStamp = 1616439852302; 115 BuiltinClocks clock = TS_CLOCK_REALTIME; 116 117 memParser->Parse(tracePacket, timeStamp, clock); 118 stream_.traceDataCache_->ExportDatabase(dbPath_); 119 120 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 121 tracePacket.clear_meminfo(); 122 delete memParser; 123 124 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); 125 EXPECT_TRUE(1 == eventCount); 126 EXPECT_EQ(3, stream_.traceDataCache_->GetConstSysMemMeasureData().Size()); 127 EXPECT_TRUE(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[0] == static_cast<int64_t>(value)); 128 EXPECT_TRUE(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[1] == static_cast<int64_t>(value2)); 129 } 130 131 /** 132 * @tc.name: ParseSysMemParseAbnomal 133 * @tc.desc: Kernel memory parsing test abnomal 134 * @tc.type: FUNC 135 */ 136 HWTEST_F(HtraceSysMemParserTest, ParseSysMemParseAbnomal, TestSize.Level1) 137 { 138 TS_LOGI("test19-3"); 139 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 140 141 MemoryData tracePacket; 142 SysMeminfo* mem = tracePacket.add_meminfo(); 143 EXPECT_TRUE(mem != nullptr); 144 int size = tracePacket.meminfo_size(); 145 EXPECT_TRUE(size == 1); 146 mem->set_key(SysMeminfoType::PMEM_MEM_TOTAL); 147 uint64_t value = random(); 148 mem->set_value(value); 149 150 mem = tracePacket.add_meminfo(); 151 EXPECT_TRUE(mem != nullptr); 152 size = tracePacket.meminfo_size(); 153 EXPECT_TRUE(size == 2); 154 mem->set_key(static_cast<SysMeminfoType>(199999)); // invalid data 155 uint64_t value2 = random(); 156 mem->set_value(value2); 157 uint64_t zarm = 100; 158 tracePacket.set_zram(zarm); 159 160 uint64_t timeStamp = 1616439852302; 161 BuiltinClocks clock = TS_CLOCK_REALTIME; 162 163 memParser->Parse(tracePacket, timeStamp, clock); 164 stream_.traceDataCache_->ExportDatabase(dbPath_); 165 166 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 167 tracePacket.clear_meminfo(); 168 delete memParser; 169 170 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); 171 EXPECT_TRUE(1 == eventCount); 172 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID); 173 EXPECT_TRUE(1 == eventCount); 174 EXPECT_EQ(2, stream_.traceDataCache_->GetConstSysMemMeasureData().Size()); 175 EXPECT_TRUE(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[0] == static_cast<int64_t>(value)); 176 } 177 178 /** 179 * @tc.name: ParseSysMemParseMutiNomal 180 * @tc.desc: Kernel memory parsing test with muti nomal 181 * @tc.type: FUNC 182 */ 183 HWTEST_F(HtraceSysMemParserTest, ParseSysMemParseMutiNomal, TestSize.Level1) 184 { 185 TS_LOGI("test19-4"); 186 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 187 188 MemoryData tracePacket; 189 SysMeminfo* mem = tracePacket.add_meminfo(); 190 EXPECT_TRUE(mem != nullptr); 191 int size = tracePacket.meminfo_size(); 192 EXPECT_TRUE(size == 1); 193 mem->set_key(SysMeminfoType::PMEM_KERNEL_RECLAIMABLE); 194 uint64_t value = random(); 195 mem->set_value(value); 196 197 mem = tracePacket.add_meminfo(); 198 EXPECT_TRUE(mem != nullptr); 199 size = tracePacket.meminfo_size(); 200 EXPECT_TRUE(size == 2); 201 mem->set_key(SysMeminfoType::SysMeminfoType_INT_MIN_SENTINEL_DO_NOT_USE_); 202 uint64_t value2 = random(); 203 mem->set_value(value2); 204 205 mem = tracePacket.add_meminfo(); 206 EXPECT_TRUE(mem != nullptr); 207 size = tracePacket.meminfo_size(); 208 EXPECT_TRUE(size == 3); 209 mem->set_key(SysMeminfoType::SysMeminfoType_INT_MAX_SENTINEL_DO_NOT_USE_); 210 uint64_t value3 = random(); 211 mem->set_value(value3); 212 uint64_t zarm = 100; 213 tracePacket.set_zram(zarm); 214 215 uint64_t timeStamp = 1616439852302; 216 BuiltinClocks clock = TS_CLOCK_REALTIME; 217 218 memParser->Parse(tracePacket, timeStamp, clock); 219 stream_.traceDataCache_->ExportDatabase(dbPath_); 220 221 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 222 tracePacket.clear_meminfo(); 223 delete memParser; 224 225 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); 226 EXPECT_TRUE(1 == eventCount); 227 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_DATA_INVALID); 228 EXPECT_TRUE(2 == eventCount); 229 EXPECT_EQ(2, stream_.traceDataCache_->GetConstSysMemMeasureData().Size()); 230 EXPECT_TRUE(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[0] == static_cast<int64_t>(value)); 231 } 232 233 /** 234 * @tc.name: ParseSysMemParseWithRandomValue 235 * @tc.desc: Kernel memory parsing test, input a random reasonable value 236 * @tc.type: FUNC 237 */ 238 HWTEST_F(HtraceSysMemParserTest, ParseSysMemParseWithRandomValue, TestSize.Level1) 239 { 240 TS_LOGI("test19-5"); 241 HtraceMemParser* memParser = new HtraceMemParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 242 243 MemoryData tracePacket; 244 245 std::map<SysMeminfoType, int64_t> sysMemValueMap_ = {}; 246 for (auto i = 0; i < SysMeminfoType::PMEM_KERNEL_RECLAIMABLE + 1; i++) { 247 uint64_t value = random(); 248 sysMemValueMap_.insert(std::make_pair(static_cast<SysMeminfoType>(i), value)); 249 SysMeminfo* mem = tracePacket.add_meminfo(); 250 EXPECT_TRUE(mem != nullptr); 251 mem->set_key(static_cast<SysMeminfoType>(i)); 252 mem->set_value(value); 253 int size = tracePacket.meminfo_size(); 254 EXPECT_TRUE(size == i + 1); 255 } 256 257 uint64_t timeStamp = 1616439852302; 258 BuiltinClocks clock = TS_CLOCK_REALTIME; 259 260 memParser->Parse(tracePacket, timeStamp, clock); 261 stream_.traceDataCache_->ExportDatabase(dbPath_); 262 263 EXPECT_TRUE(access(dbPath_.c_str(), F_OK) == 0); 264 tracePacket.clear_meminfo(); 265 delete memParser; 266 267 auto eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_SYS_MEMORY, STAT_EVENT_RECEIVED); 268 EXPECT_TRUE(1 == eventCount); 269 270 for (auto i = 0; i < SysMeminfoType::PMEM_KERNEL_RECLAIMABLE + 1; i++) { 271 EXPECT_TRUE(stream_.traceDataCache_->GetConstSysMemMeasureData().ValuesData()[i] == 272 sysMemValueMap_.at(static_cast<SysMeminfoType>(i))); 273 } 274 } 275 } // namespace TraceStreamer 276 } // namespace SysTuning 277