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 #ifndef ACTIVITY_MONITOR_STDTYPE_H 17 #define ACTIVITY_MONITOR_STDTYPE_H 18 #include "base_stdtype.h" 19 20 namespace SysTuning { 21 namespace TraceStdtype { 22 class Hidump : public CacheBase { 23 public: 24 size_t AppendNewHidumpInfo(uint64_t timeStamp, uint32_t fps); 25 const std::deque<uint32_t> &Fpss() const; 26 void Clear() override; 27 28 private: 29 std::deque<uint32_t> fpss_ = {}; 30 }; 31 struct DiskIoRow { 32 uint64_t ts = INVALID_UINT64; 33 uint64_t dur = INVALID_UINT64; 34 uint64_t rd = INVALID_UINT64; 35 uint64_t wr = INVALID_UINT64; 36 uint64_t rdPerSec = INVALID_UINT64; 37 uint64_t wrPerSec = INVALID_UINT64; 38 double rdCountPerSec = 0; 39 double wrCountPerSec = 0; 40 uint64_t rdCount = INVALID_UINT64; 41 uint64_t wrCount = INVALID_UINT64; 42 }; 43 44 class DiskIOData : public CacheBase { 45 public: 46 DiskIOData() = default; 47 ~DiskIOData() = default; 48 void AppendNewData(const DiskIoRow &diskioRow); 49 const std::deque<uint64_t> &Durs() const; 50 const std::deque<uint64_t> &RdDatas() const; 51 const std::deque<uint64_t> &WrDatas() const; 52 const std::deque<double> &RdSpeedDatas() const; 53 const std::deque<double> &WrSpeedDatas() const; 54 const std::deque<double> &RdCountPerSecDatas() const; 55 const std::deque<double> &WrCountPerSecDatas() const; 56 const std::deque<uint64_t> &RdCountDatas() const; 57 const std::deque<uint64_t> &WrCountDatas() const; 58 void Clear() override; 59 60 private: 61 std::deque<uint64_t> durs_ = {}; 62 std::deque<uint64_t> rdDatas_ = {}; 63 std::deque<uint64_t> wrDatas_ = {}; 64 std::deque<double> wrPerSec_ = {}; 65 std::deque<double> rdPerSec_ = {}; 66 std::deque<double> wrCountPerSec_ = {}; 67 std::deque<double> rdCountPerSec_ = {}; 68 std::deque<uint64_t> rdCountDatas_ = {}; 69 std::deque<uint64_t> wrCountDatas_ = {}; 70 }; 71 struct LiveProcessDetailRow { 72 uint64_t newTimeStamp = INVALID_UINT64; 73 uint64_t dur = INVALID_UINT64; 74 int32_t processID = INVALID_INT32; 75 std::string processName = ""; 76 int32_t parentProcessID = INVALID_INT32; 77 int32_t uid = INVALID_INT32; 78 std::string userName = ""; 79 double cpuUsage = 0; 80 int32_t pssInfo = INVALID_INT32; 81 uint64_t cpuTime = INVALID_UINT64; 82 int32_t threads = INVALID_INT32; 83 int64_t diskWrites = INVALID_INT64; 84 int64_t diskReads = INVALID_INT64; 85 }; 86 class LiveProcessDetailData : public CacheBase { 87 public: 88 size_t AppendNewData(const LiveProcessDetailRow &liveProcessDetailRow); 89 const std::deque<uint64_t> &Durs() const; 90 const std::deque<int32_t> &ProcessID() const; 91 const std::deque<std::string> &ProcessName() const; 92 const std::deque<int32_t> &ParentProcessID() const; 93 const std::deque<int32_t> &Uid() const; 94 const std::deque<std::string> &UserName() const; 95 const std::deque<double> &CpuUsage() const; 96 const std::deque<int32_t> &PssInfo() const; 97 const std::deque<int32_t> &Threads() const; 98 const std::deque<int64_t> &DiskWrites() const; 99 const std::deque<int64_t> &DiskReads() const; 100 const std::deque<uint64_t> &CpuTimes() const; 101 void Clear() override; 102 103 private: 104 std::deque<uint64_t> durs_ = {}; 105 std::deque<int32_t> processID_ = {}; 106 std::deque<std::string> processName_ = {}; 107 std::deque<int32_t> parentProcessID_ = {}; 108 std::deque<int32_t> uid_ = {}; 109 std::deque<std::string> userName_ = {}; 110 std::deque<double> cpuUsage_ = {}; 111 std::deque<int32_t> pssInfo_ = {}; 112 std::deque<int32_t> threads_ = {}; 113 std::deque<int64_t> diskWrites_ = {}; 114 std::deque<int64_t> diskReads_ = {}; 115 std::deque<uint64_t> cpuTimes_ = {}; 116 }; 117 struct CpuUsageDetailRow { 118 uint64_t newTimeStamp = INVALID_UINT64; 119 uint64_t dur = INVALID_UINT64; 120 double totalLoad = 0; 121 double userLoad = 0; 122 double systemLoad = 0; 123 int64_t threads = INVALID_INT64; 124 }; 125 class CpuUsageDetailData : public CacheBase { 126 public: 127 size_t AppendNewData(const CpuUsageDetailRow &cpuUsageDetailRow); 128 const std::deque<uint64_t> &Durs() const; 129 const std::deque<double> &TotalLoad() const; 130 const std::deque<double> &UserLoad() const; 131 const std::deque<double> &SystemLoad() const; 132 const std::deque<int64_t> &Threads() const; 133 void Clear() override; 134 135 private: 136 std::deque<uint64_t> durs_ = {}; 137 std::deque<double> totalLoad_ = {}; 138 std::deque<double> userLoad_ = {}; 139 std::deque<double> systemLoad_ = {}; 140 std::deque<int64_t> threads_ = {}; 141 }; 142 struct NetDetailRow { 143 uint64_t newTimeStamp = INVALID_UINT64; 144 uint64_t tx = INVALID_UINT64; 145 uint64_t rx = INVALID_UINT64; 146 uint64_t dur = INVALID_UINT64; 147 double rxSpeed = 0; 148 double txSpeed = 0; 149 uint64_t packetIn = INVALID_UINT64; 150 double packetInSec = 0; 151 uint64_t packetOut = INVALID_UINT64; 152 double packetOutSec = 0; 153 std::string netType = ""; 154 }; 155 class NetDetailData : public CacheBase { 156 public: 157 size_t AppendNewNetData(const NetDetailRow &NetDetailRow); 158 const std::deque<uint64_t> &Durs() const; 159 const std::deque<double> &RxSpeed() const; 160 const std::deque<double> &TxSpeed() const; 161 const std::deque<std::string> &NetTypes() const; 162 const std::deque<uint64_t> &RxDatas() const; 163 const std::deque<uint64_t> &TxDatas() const; 164 const std::deque<uint64_t> &PacketIn() const; 165 const std::deque<double> &PacketInSec() const; 166 const std::deque<uint64_t> &PacketOut() const; 167 const std::deque<double> &PacketOutSec() const; 168 void Clear() override; 169 170 private: 171 std::deque<uint64_t> rxs_ = {}; 172 std::deque<uint64_t> txs_ = {}; 173 std::deque<uint64_t> durs_ = {}; 174 std::deque<double> rxSpeeds_ = {}; 175 std::deque<double> txSpeeds_ = {}; 176 std::deque<uint64_t> packetIn_ = {}; 177 std::deque<double> packetInSec_ = {}; 178 std::deque<uint64_t> packetOut_ = {}; 179 std::deque<double> packetOutSec_ = {}; 180 std::deque<std::string> netTypes_ = {}; 181 }; 182 struct SmapsRow { 183 uint64_t timeStamp = INVALID_UINT64; 184 uint64_t ipid = INVALID_UINT64; 185 std::string startAddr = ""; 186 std::string endAddr = ""; 187 uint64_t dirty = INVALID_UINT64; 188 uint64_t swapper = INVALID_UINT64; 189 uint64_t rss = INVALID_UINT64; 190 uint64_t pss = INVALID_UINT64; 191 uint64_t size = INVALID_UINT64; 192 double reside = 0; 193 DataIndex protectionId = INVALID_UINT64; 194 DataIndex pathId = INVALID_UINT64; 195 uint64_t sharedClean = INVALID_UINT64; 196 uint64_t sharedDirty = INVALID_UINT64; 197 uint64_t privateClean = INVALID_UINT64; 198 uint64_t privateDirty = INVALID_UINT64; 199 uint64_t swap = INVALID_UINT64; 200 uint64_t swapPss = INVALID_UINT64; 201 uint32_t type = INVALID_UINT32; 202 }; 203 204 class SmapsData : public CacheBase { 205 public: 206 void AppendNewData(const SmapsRow &smapsRow); 207 const std::deque<uint64_t> &TimeStamps() const; 208 const std::deque<uint64_t> &Ipids() const; 209 const std::deque<std::string> &StartAddrs() const; 210 const std::deque<std::string> &EndAddrs() const; 211 const std::deque<uint64_t> &Dirtys() const; 212 const std::deque<uint64_t> &Swappers() const; 213 const std::deque<uint64_t> &Rss() const; 214 const std::deque<uint64_t> &Pss() const; 215 const std::deque<uint64_t> &Sizes() const; 216 const std::deque<double> &Resides() const; 217 const std::deque<DataIndex> &ProtectionIds() const; 218 const std::deque<DataIndex> &PathIds() const; 219 const std::deque<uint64_t> &SharedClean() const; 220 const std::deque<uint64_t> &SharedDirty() const; 221 const std::deque<uint64_t> &PrivateClean() const; 222 const std::deque<uint64_t> &PrivateDirty() const; 223 const std::deque<uint64_t> &Swap() const; 224 const std::deque<uint64_t> &SwapPss() const; 225 const std::deque<uint32_t> &Type() const; 226 void Clear() override; 227 228 private: 229 std::deque<uint64_t> ipids_ = {}; 230 std::deque<std::string> startAddrs_ = {}; 231 std::deque<std::string> endAddrs_ = {}; 232 std::deque<uint64_t> dirtys_ = {}; 233 std::deque<uint64_t> swappers_ = {}; 234 std::deque<uint64_t> rss_ = {}; 235 std::deque<uint64_t> pss_ = {}; 236 std::deque<uint64_t> sizes_ = {}; 237 std::deque<double> resides_ = {}; 238 std::deque<DataIndex> protectionIds_ = {}; 239 std::deque<DataIndex> pathIds_ = {}; 240 std::deque<uint64_t> sharedClean_ = {}; 241 std::deque<uint64_t> sharedDirty_ = {}; 242 std::deque<uint64_t> privateClean_ = {}; 243 std::deque<uint64_t> privateDirty_ = {}; 244 std::deque<uint64_t> swap_ = {}; 245 std::deque<uint64_t> swapPss_ = {}; 246 std::deque<uint32_t> type_ = {}; 247 uint32_t rowCount_ = 0; 248 }; 249 250 struct AshMemRow { 251 InternalPid ipid = INVALID_IPID; 252 uint64_t ts = INVALID_UINT64; 253 uint32_t adj = INVALID_UINT32; 254 uint32_t fd = INVALID_UINT32; 255 DataIndex ashmemNameId = INVALID_UINT64; 256 uint64_t size = INVALID_UINT64; 257 uint64_t pss = INVALID_UINT64; 258 uint32_t ashmemId = INVALID_UINT32; 259 uint64_t time = INVALID_UINT64; 260 uint64_t refCount = INVALID_UINT64; 261 uint64_t purged = INVALID_UINT64; 262 uint32_t flag = INVALID_UINT32; 263 }; 264 265 class AshMemData : public CacheBase { 266 public: 267 void AppendNewData(const AshMemRow &ashMemRow); 268 const std::deque<InternalPid> &Ipids() const; 269 const std::deque<uint32_t> &Adjs() const; 270 const std::deque<uint32_t> &Fds() const; 271 const std::deque<DataIndex> &AshmemNameIds() const; 272 const std::deque<uint64_t> &Sizes() const; 273 const std::deque<uint64_t> &Psss() const; 274 const std::deque<uint32_t> &AshmemIds() const; 275 const std::deque<uint64_t> &Times() const; 276 const std::deque<uint64_t> &RefCounts() const; 277 const std::deque<uint64_t> &Purgeds() const; 278 const std::deque<uint32_t> &Flags() const; 279 void SetFlag(uint64_t rowId, uint32_t flag); 280 void Clear() override; 281 282 private: 283 std::deque<InternalPid> ipids_ = {}; 284 std::deque<uint32_t> adjs_ = {}; 285 std::deque<uint32_t> fds_ = {}; 286 std::deque<DataIndex> ashmemNameIds_ = {}; 287 std::deque<uint64_t> sizes_ = {}; 288 std::deque<uint64_t> psss_ = {}; 289 std::deque<uint32_t> ashmemIds_ = {}; 290 std::deque<uint64_t> times_ = {}; 291 std::deque<uint64_t> refCounts_ = {}; 292 std::deque<uint64_t> purgeds_ = {}; 293 std::deque<uint32_t> flags_ = {}; 294 uint32_t rowCount_ = 0; 295 }; 296 297 struct DmaMemRow { 298 InternalPid ipid = INVALID_IPID; 299 uint64_t ts = INVALID_UINT64; 300 uint32_t fd = INVALID_UINT32; 301 uint64_t size = INVALID_UINT64; 302 uint32_t ino = INVALID_UINT32; 303 uint32_t expPid = INVALID_UINT32; 304 DataIndex expTaskCommId = INVALID_DATAINDEX; 305 DataIndex bufNameId = INVALID_DATAINDEX; 306 DataIndex expNameId = INVALID_DATAINDEX; 307 uint32_t flag = INVALID_UINT32; 308 }; 309 310 class DmaMemData : public CacheBase { 311 public: 312 void AppendNewData(const DmaMemRow &dmaMemRow); 313 const std::deque<InternalPid> &Ipids() const; 314 const std::deque<uint32_t> &Fds() const; 315 const std::deque<uint64_t> &Sizes() const; 316 const std::deque<uint32_t> &Inos() const; 317 const std::deque<uint32_t> &ExpPids() const; 318 const std::deque<DataIndex> &ExpTaskCommIds() const; 319 const std::deque<DataIndex> &BufNameIds() const; 320 const std::deque<DataIndex> &ExpNameIds() const; 321 const std::deque<uint32_t> &Flags() const; 322 void SetFlag(uint64_t rowId, uint32_t flag); 323 void Clear() override; 324 325 private: 326 std::deque<InternalPid> ipids_ = {}; 327 std::deque<uint32_t> fds_ = {}; 328 std::deque<uint64_t> sizes_ = {}; 329 std::deque<uint32_t> inos_ = {}; 330 std::deque<uint32_t> expPids_ = {}; 331 std::deque<DataIndex> expTaskCommIds_ = {}; 332 std::deque<DataIndex> bufNameIds_ = {}; 333 std::deque<DataIndex> expNameIds_ = {}; 334 std::deque<uint32_t> flags_ = {}; 335 uint32_t rowCount_ = 0; 336 }; 337 338 struct GpuProcessMemRow { 339 uint64_t ts = INVALID_UINT64; 340 DataIndex gpuNameId = INVALID_DATAINDEX; 341 uint64_t allGpuSize = INVALID_UINT64; 342 std::string addr = ""; 343 InternalPid ipid = INVALID_IPID; 344 InternalPid itid = INVALID_ITID; 345 uint64_t usedGpuSize = INVALID_UINT64; 346 }; 347 class GpuProcessMemData : public CacheBase { 348 public: 349 void AppendNewData(const GpuProcessMemRow &gpuProcessMemRow); 350 const std::deque<DataIndex> &GpuNameIds() const; 351 const std::deque<uint64_t> &AllGpuSizes() const; 352 const std::deque<std::string> &Addrs() const; 353 const std::deque<InternalPid> &Ipids() const; 354 const std::deque<InternalPid> &Itids() const; 355 const std::deque<uint64_t> &UsedGpuSizes() const; 356 void Clear() override; 357 358 private: 359 std::deque<DataIndex> gpuNameIds_ = {}; 360 std::deque<uint64_t> allGpuSizes_ = {}; 361 std::deque<std::string> addrs_ = {}; 362 std::deque<InternalPid> ipids_ = {}; 363 std::deque<InternalPid> itids_ = {}; 364 std::deque<uint64_t> usedGpuSizes_ = {}; 365 uint32_t rowCount_ = 0; 366 }; 367 struct GpuWindowMemRow { 368 uint64_t ts = INVALID_UINT64; 369 DataIndex windowNameId = INVALID_UINT64; 370 uint64_t windowId = INVALID_UINT64; 371 DataIndex moduleNameId = INVALID_UINT64; 372 DataIndex categoryNameId = INVALID_UINT64; 373 uint64_t size = INVALID_UINT64; 374 uint32_t count = INVALID_UINT32; 375 uint64_t purgeableSize = INVALID_UINT64; 376 }; 377 class GpuWindowMemData : public CacheBase { 378 public: 379 void AppendNewData(const GpuWindowMemRow &gpuWindowMemRow); 380 void RevicesIpid(const std::map<DataIndex, InternalPid> &windowIdToIpidMap); 381 const std::deque<DataIndex> &WindowNameIds() const; 382 const std::deque<uint64_t> &WindowIds() const; 383 const std::deque<DataIndex> &ModuleNameIds() const; 384 const std::deque<DataIndex> &CategoryNameIds() const; 385 const std::deque<uint64_t> &Sizes() const; 386 const std::deque<uint32_t> &Counts() const; 387 const std::deque<uint64_t> &PurgeableSizes() const; 388 const std::deque<InternalPid> &Ipids() const; 389 void Clear() override; 390 391 private: 392 std::deque<DataIndex> windowNameIds_ = {}; 393 std::deque<uint64_t> windowIds_ = {}; 394 std::deque<DataIndex> moduleNameIds_ = {}; 395 std::deque<DataIndex> categoryNameIds_ = {}; 396 std::deque<uint64_t> sizes_ = {}; 397 std::deque<uint32_t> counts_ = {}; 398 std::deque<uint64_t> purgeableSizes_ = {}; 399 std::deque<InternalPid> ipids_ = {}; 400 uint32_t rowCount_ = 0; 401 }; 402 class CpuDumpInfo : public CacheBase { 403 public: 404 void AppendNewData(uint64_t timestamp, uint64_t size); 405 const std::deque<uint64_t> &TotalSizes() const; 406 void Clear() override; 407 408 private: 409 std::deque<uint64_t> totalSizes_ = {}; 410 }; 411 412 class ProfileMemInfo : public CacheBase { 413 public: 414 void AppendNewData(uint64_t timestamp, DataIndex channelIndex, uint64_t size); 415 const std::deque<uint64_t> &ChannelIndexs() const; 416 const std::deque<uint64_t> &TotalSizes() const; 417 void Clear() override; 418 419 private: 420 std::deque<DataIndex> channelIndexs_ = {}; 421 std::deque<uint64_t> totalSizes_ = {}; 422 }; 423 class RSImageDumpInfo : public CacheBase { 424 public: 425 void AppendNewData(uint64_t timestamp, uint64_t memSize, DataIndex typeIndex, InternalPid ipid, DataIndex name); 426 const std::deque<uint64_t> &MemSizes() const; 427 const std::deque<DataIndex> &TypeIndexs() const; 428 const std::deque<InternalPid> &Ipids() const; 429 const std::deque<DataIndex> &SurfaceNameIndexs() const; 430 void Clear() override; 431 432 private: 433 std::deque<uint64_t> memSizes_ = {}; 434 std::deque<DataIndex> typeIndexs_ = {}; 435 std::deque<InternalPid> ipids_ = {}; 436 std::deque<DataIndex> surfaceNameIndexs_ = {}; 437 }; 438 } // namespace TraceStdtype 439 } // namespace SysTuning 440 #endif // ACTIVITY_MONITOR_STDTYPE_H 441