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 #ifndef TRACE_STDTYPE_H 17 #define TRACE_STDTYPE_H 18 19 #include <array> 20 #include <deque> 21 #include <limits> 22 #include <map> 23 #include <mutex> 24 #include <optional> 25 #include <regex> 26 #include <sstream> 27 #include <stdexcept> 28 #include <string> 29 #include <unordered_map> 30 #include <vector> 31 32 #include "cfg/trace_streamer_config.h" 33 #include "double_map.h" 34 #include "log.h" 35 #include "ts_common.h" 36 37 namespace SysTuning { 38 namespace TraceStdtype { 39 using namespace SysTuning::TraceCfg; 40 using namespace SysTuning::TraceStreamer; 41 constexpr uint32_t ONE_MILLION_NANOSECONDS = 1000000; 42 constexpr uint32_t BILLION_NANOSECONDS = 1000000000; 43 constexpr uint8_t DYNAMICFRAME_MATCH_LAST = 5; 44 class CacheBase { 45 public: Size()46 size_t Size() const 47 { 48 return std::max(timeStamps_.size(), ids_.size()); 49 } IdsData()50 const std::deque<uint64_t>& IdsData() const 51 { 52 return ids_; 53 } TimeStampData()54 const std::deque<uint64_t>& TimeStampData() const 55 { 56 return timeStamps_; 57 } InternalTidsData()58 const std::deque<InternalTid>& InternalTidsData() const 59 { 60 return internalTids_; 61 } Clear()62 virtual void Clear() 63 { 64 internalTids_.clear(); 65 timeStamps_.clear(); 66 ids_.clear(); 67 } 68 69 public: 70 std::deque<InternalTid> internalTids_ = {}; 71 std::deque<uint64_t> timeStamps_ = {}; 72 std::deque<uint64_t> ids_ = {}; 73 }; 74 75 class CpuCacheBase { 76 public: DursData()77 const std::deque<uint64_t>& DursData() const 78 { 79 return durs_; 80 } 81 CpusData()82 const std::deque<uint32_t>& CpusData() const 83 { 84 return cpus_; 85 } Clear()86 virtual void Clear() 87 { 88 durs_.clear(); 89 cpus_.clear(); 90 } 91 void SetDur(uint64_t index, uint64_t dur); 92 93 public: 94 std::deque<uint64_t> durs_; 95 std::deque<uint32_t> cpus_; 96 }; 97 class Thread { 98 public: Thread(uint32_t t)99 explicit Thread(uint32_t t) : tid_(t) {} 100 InternalPid internalPid_ = INVALID_UINT32; 101 uint32_t tid_ = 0; 102 DataIndex nameIndex_ = 0; 103 InternalTime startT_ = 0; 104 InternalTime endT_ = 0; 105 uint32_t switchCount_ = 0; 106 uint32_t sliceSize_ = 0; 107 uint32_t cpuStatesCount_ = 0; 108 }; 109 110 class Process { 111 public: Process(uint32_t p)112 explicit Process(uint32_t p) : pid_(p) {} 113 std::string cmdLine_ = ""; 114 InternalTime startT_ = 0; 115 uint32_t pid_ = 0; 116 uint32_t memSize_ = 0; 117 uint32_t threadSize_ = 0; 118 uint32_t sliceSize_ = 0; 119 uint32_t switchCount_ = 0; 120 int32_t threadCount_ = -1; 121 uint32_t cpuStatesCount_ = 0; 122 }; 123 124 class ThreadStateData { 125 public: 126 TableRowId 127 AppendThreadState(InternalTime ts, InternalTime dur, InternalCpu cpu, InternalTid itid, TableRowId idState); 128 void SetDuration(TableRowId index, InternalTime dur); 129 TableRowId UpdateDuration(TableRowId index, InternalTime ts); 130 bool End(TableRowId index, InternalTime ts); 131 void UpdateState(TableRowId index, TableRowId idState); 132 void SetArgSetId(TableRowId index, uint32_t setId); 133 void UpdateDuration(TableRowId index, InternalTime ts, TableRowId idState); 134 void UpdateTidAndPid(TableRowId index, InternalTid tid, InternalTid pid); 135 TableRowId UpdateDuration(TableRowId index, InternalTime ts, InternalCpu cpu, TableRowId idState); Clear()136 void Clear() 137 { 138 timeStamps_.clear(); 139 durations_.clear(); 140 itids_.clear(); 141 tids_.clear(); 142 pids_.clear(); 143 states_.clear(); 144 cpus_.clear(); 145 } Size()146 uint32_t Size() const 147 { 148 return itids_.size(); 149 } 150 TimeStamsData()151 const std::deque<InternalTime>& TimeStamsData() const 152 { 153 return timeStamps_; 154 } DursData()155 const std::deque<InternalTime>& DursData() const 156 { 157 return durations_; 158 } ItidsData()159 const std::deque<InternalTid>& ItidsData() const 160 { 161 return itids_; 162 } TidsData()163 const std::deque<InternalTid>& TidsData() const 164 { 165 return tids_; 166 } PidsData()167 const std::deque<InternalPid>& PidsData() const 168 { 169 return pids_; 170 } StatesData()171 const std::deque<DataIndex>& StatesData() const 172 { 173 return states_; 174 } CpusData()175 const std::deque<InternalCpu>& CpusData() const 176 { 177 return cpus_; 178 } ArgSetsData()179 const std::deque<uint32_t>& ArgSetsData() const 180 { 181 return argSetIds_; 182 } 183 184 private: 185 std::deque<InternalTime> timeStamps_; 186 std::deque<InternalTime> durations_; 187 std::deque<InternalTid> itids_; 188 std::deque<InternalTid> tids_; 189 std::deque<InternalPid> pids_; 190 std::deque<DataIndex> states_; 191 std::deque<InternalCpu> cpus_; 192 std::deque<uint32_t> argSetIds_; 193 }; 194 195 class SchedSlice : public CacheBase, public CpuCacheBase { 196 public: 197 size_t AppendSchedSlice(uint64_t ts, 198 uint64_t dur, 199 uint64_t cpu, 200 uint32_t internalTid, 201 uint64_t endState, 202 uint64_t priority); 203 void SetDuration(size_t index, uint64_t duration); 204 void Update(uint64_t index, uint64_t ts, uint64_t state); 205 void UpdateArg(uint64_t index, uint32_t argsetId); 206 EndStatesData()207 const std::deque<uint64_t>& EndStatesData() const 208 { 209 return endStates_; 210 } 211 PriorityData()212 const std::deque<uint64_t>& PriorityData() const 213 { 214 return priority_; 215 } 216 ArgSetData()217 const std::deque<uint32_t>& ArgSetData() const 218 { 219 return argSets_; 220 } TsEndData()221 const std::deque<uint64_t>& TsEndData() const 222 { 223 return tsEnds_; 224 } InternalPidsData()225 const std::deque<InternalPid>& InternalPidsData() const 226 { 227 return internalPids_; 228 } AppendInternalPid(InternalPid ipid)229 void AppendInternalPid(InternalPid ipid) 230 { 231 internalPids_.emplace_back(ipid); 232 } Clear()233 void Clear() override 234 { 235 CacheBase::Clear(); 236 CpuCacheBase::Clear(); 237 endStates_.clear(); 238 priority_.clear(); 239 internalPids_.clear(); 240 tsEnds_.clear(); 241 } 242 243 private: 244 std::deque<InternalPid> internalPids_ = {}; 245 std::deque<uint64_t> tsEnds_ = {}; 246 std::deque<uint64_t> endStates_ = {}; 247 std::deque<uint64_t> priority_ = {}; 248 std::deque<uint32_t> argSets_ = {}; 249 }; 250 251 class CallStack : public CacheBase, public CpuCacheBase { 252 public: 253 size_t AppendInternalAsyncSlice(uint64_t startT, 254 uint64_t durationNs, 255 InternalTid internalTid, 256 DataIndex cat, 257 uint16_t nameIdentify, 258 DataIndex name, 259 uint8_t depth, 260 uint64_t cookid, 261 const std::optional<uint64_t>& parentId); 262 size_t AppendInternalSlice(uint64_t startT, 263 uint64_t durationNs, 264 InternalTid internalTid, 265 DataIndex cat, 266 uint16_t nameIdentify, 267 DataIndex name, 268 uint8_t depth, 269 const std::optional<uint64_t>& parentId); 270 void SetDistributeInfo(size_t index, 271 const std::string& chainId, 272 const std::string& spanId, 273 const std::string& parentSpanId, 274 const std::string& flag, 275 const std::string& args); 276 void AppendDistributeInfo(const std::string& chainId, 277 const std::string& spanId, 278 const std::string& parentSpanId, 279 const std::string& flag, 280 const std::string& args); 281 void AppendDistributeInfo(); 282 void SetDuration(size_t index, uint64_t timeStamp); 283 void SetDurationWithFlag(size_t index, uint64_t timeStamp); 284 void SetFlag(size_t index, uint8_t flag); 285 void SetDurationEx(size_t index, uint32_t dur); 286 void SetIrqDurAndArg(size_t index, uint64_t timeStamp, uint32_t argSetId); 287 void SetTimeStamp(size_t index, uint64_t timeStamp); 288 void SetDepth(size_t index, uint8_t depth); 289 void SetArgSetId(size_t index, uint32_t argSetId); Clear()290 void Clear() override 291 { 292 CacheBase::Clear(); 293 CpuCacheBase::Clear(); 294 cats_.clear(); 295 cookies_.clear(); 296 callIds_.clear(); 297 names_.clear(); 298 depths_.clear(); 299 chainIds_.clear(); 300 spanIds_.clear(); 301 parentSpanIds_.clear(); 302 flags_.clear(); 303 args_.clear(); 304 argSet_.clear(); 305 } 306 307 const std::deque<std::optional<uint64_t>>& ParentIdData() const; 308 const std::deque<DataIndex>& CatsData() const; 309 const std::deque<DataIndex>& NamesData() const; 310 const std::deque<uint8_t>& Depths() const; 311 const std::deque<uint64_t>& Cookies() const; 312 const std::deque<uint32_t>& CallIds() const; 313 const std::deque<uint16_t>& IdentifysData() const; 314 const std::deque<std::string>& ChainIds() const; 315 const std::deque<std::string>& SpanIds() const; 316 const std::deque<std::string>& ParentSpanIds() const; 317 const std::deque<std::string>& Flags() const; 318 const std::deque<std::string>& ArgsData() const; 319 const std::deque<uint32_t>& ArgSetIdsData() const; 320 321 private: 322 void AppendCommonInfo(uint64_t startT, uint64_t durationNs, InternalTid internalTid); 323 void AppendCallStack(DataIndex cat, DataIndex name, uint8_t depth, std::optional<uint64_t> parentId); 324 325 private: 326 std::deque<std::optional<uint64_t>> parentIds_; 327 std::deque<DataIndex> cats_ = {}; 328 std::deque<uint64_t> cookies_ = {}; 329 std::deque<uint32_t> callIds_ = {}; 330 std::deque<uint16_t> identifys_ = {}; 331 std::deque<DataIndex> names_ = {}; 332 std::deque<uint8_t> depths_ = {}; 333 334 std::deque<std::string> chainIds_ = {}; 335 std::deque<std::string> spanIds_ = {}; 336 std::deque<std::string> parentSpanIds_ = {}; 337 std::deque<std::string> flags_ = {}; 338 std::deque<std::string> args_ = {}; 339 std::deque<uint32_t> argSet_ = {}; 340 }; 341 342 class Filter : public CacheBase { 343 public: 344 size_t AppendNewFilterData(std::string type, std::string name, uint64_t sourceArgSetId); NameData()345 const std::deque<std::string>& NameData() const 346 { 347 return nameDeque_; 348 } TypeData()349 const std::deque<std::string>& TypeData() const 350 { 351 return typeDeque_; 352 } SourceArgSetIdData()353 const std::deque<uint64_t>& SourceArgSetIdData() const 354 { 355 return sourceArgSetId_; 356 } Clear()357 void Clear() override 358 { 359 CacheBase::Clear(); 360 nameDeque_.clear(); 361 typeDeque_.clear(); 362 sourceArgSetId_.clear(); 363 } 364 365 private: 366 std::deque<std::string> nameDeque_ = {}; 367 std::deque<std::string> typeDeque_ = {}; 368 std::deque<uint64_t> sourceArgSetId_ = {}; 369 }; 370 371 class Measure : public CacheBase { 372 public: 373 size_t AppendMeasureData(uint32_t type, uint64_t timeStamp, int64_t value, uint32_t filterId); TypeData()374 const std::deque<uint32_t>& TypeData() const 375 { 376 return typeDeque_; 377 } ValuesData()378 const std::deque<int64_t>& ValuesData() const 379 { 380 return valuesDeque_; 381 } DursData()382 const std::deque<uint64_t>& DursData() const 383 { 384 return durDeque_; 385 } 386 void SetDur(uint32_t row, uint64_t timeStamp); FilterIdData()387 const std::deque<uint32_t>& FilterIdData() const 388 { 389 return filterIdDeque_; 390 } Clear()391 void Clear() override 392 { 393 CacheBase::Clear(); 394 typeDeque_.clear(); 395 durDeque_.clear(); 396 valuesDeque_.clear(); 397 filterIdDeque_.clear(); 398 } 399 400 private: 401 std::deque<uint32_t> typeDeque_ = {}; 402 std::deque<uint64_t> durDeque_ = {}; 403 std::deque<int64_t> valuesDeque_ = {}; 404 std::deque<uint32_t> filterIdDeque_ = {}; 405 }; 406 407 class Raw : public CacheBase { 408 public: 409 size_t AppendRawData(uint32_t id, uint64_t timeStamp, uint32_t name, uint32_t cpu, uint32_t internalTid); NameData()410 const std::deque<uint32_t>& NameData() const 411 { 412 return nameDeque_; 413 } CpuData()414 const std::deque<uint32_t>& CpuData() const 415 { 416 return cpuDeque_; 417 } InternalTidData()418 const std::deque<uint32_t>& InternalTidData() const 419 { 420 return itidDeque_; 421 } Clear()422 void Clear() override 423 { 424 CacheBase::Clear(); 425 nameDeque_.clear(); 426 cpuDeque_.clear(); 427 itidDeque_.clear(); 428 } 429 430 private: 431 std::deque<uint32_t> nameDeque_ = {}; 432 std::deque<uint32_t> cpuDeque_ = {}; 433 std::deque<uint32_t> itidDeque_ = {}; 434 }; 435 436 class ThreadMeasureFilter { 437 public: 438 size_t AppendNewFilter(uint64_t filterId, uint32_t nameIndex, uint64_t internalTid); Size()439 size_t Size() const 440 { 441 return filterId_.size(); 442 } FilterIdData()443 const std::deque<uint64_t>& FilterIdData() const 444 { 445 return filterId_; 446 } InternalTidData()447 const std::deque<uint64_t>& InternalTidData() const 448 { 449 return internalTids_; 450 } NameIndexData()451 const std::deque<uint32_t>& NameIndexData() const 452 { 453 return nameIndex_; 454 } Clear()455 void Clear() 456 { 457 filterId_.clear(); 458 internalTids_.clear(); 459 nameIndex_.clear(); 460 } 461 462 private: 463 std::deque<uint64_t> filterId_ = {}; 464 std::deque<uint64_t> internalTids_ = {}; 465 std::deque<uint32_t> nameIndex_ = {}; 466 }; 467 468 class CpuMeasureFilter : public CacheBase { 469 public: AppendNewFilter(uint64_t filterId,DataIndex name,uint32_t cpu)470 inline size_t AppendNewFilter(uint64_t filterId, DataIndex name, uint32_t cpu) 471 { 472 ids_.emplace_back(filterId); 473 cpu_.emplace_back(cpu); 474 name_.emplace_back(name); 475 return Size() - 1; 476 } 477 CpuData()478 const std::deque<uint32_t>& CpuData() const 479 { 480 return cpu_; 481 } 482 TypeData()483 const std::deque<DataIndex>& TypeData() const 484 { 485 return type_; 486 } 487 NameData()488 const std::deque<DataIndex>& NameData() const 489 { 490 return name_; 491 } Clear()492 void Clear() override 493 { 494 CacheBase::Clear(); 495 cpu_.clear(); 496 type_.clear(); 497 name_.clear(); 498 } 499 500 private: 501 std::deque<uint32_t> cpu_ = {}; 502 std::deque<DataIndex> type_ = {}; 503 std::deque<DataIndex> name_ = {}; 504 }; 505 506 class Instants : public CacheBase { 507 public: 508 size_t AppendInstantEventData(uint64_t timeStamp, 509 DataIndex nameIndex, 510 int64_t internalTid, 511 int64_t wakeupFromInternalPid); 512 NameIndexsData()513 const std::deque<DataIndex>& NameIndexsData() const 514 { 515 return NameIndexs_; 516 } WakeupFromPidsData()517 const std::deque<int64_t>& WakeupFromPidsData() const 518 { 519 return wakeupFromInternalPids_; 520 } Clear()521 void Clear() override 522 { 523 CacheBase::Clear(); 524 NameIndexs_.clear(); 525 wakeupFromInternalPids_.clear(); 526 } 527 528 private: 529 std::deque<DataIndex> NameIndexs_; 530 std::deque<int64_t> wakeupFromInternalPids_; 531 }; 532 533 class ProcessMeasureFilter : public CacheBase { 534 public: 535 size_t AppendNewFilter(uint64_t id, DataIndex name, uint32_t internalPid); 536 UpidsData()537 const std::deque<uint32_t>& UpidsData() const 538 { 539 return internalPids_; 540 } 541 NamesData()542 const std::deque<DataIndex>& NamesData() const 543 { 544 return names_; 545 } Clear()546 void Clear() override 547 { 548 CacheBase::Clear(); 549 internalPids_.clear(); 550 names_.clear(); 551 } 552 553 private: 554 std::deque<uint32_t> internalPids_ = {}; 555 std::deque<DataIndex> names_ = {}; 556 }; 557 class ClockEventData : public CacheBase { 558 public: 559 size_t AppendNewFilter(uint64_t id, DataIndex type, DataIndex name, uint64_t cpu); 560 CpusData()561 const std::deque<uint64_t>& CpusData() const 562 { 563 return cpus_; 564 } 565 NamesData()566 const std::deque<DataIndex>& NamesData() const 567 { 568 return names_; 569 } TypesData()570 const std::deque<DataIndex>& TypesData() const 571 { 572 return types_; 573 } Clear()574 void Clear() override 575 { 576 CacheBase::Clear(); 577 cpus_.clear(); 578 names_.clear(); 579 types_.clear(); 580 } 581 582 private: 583 std::deque<uint64_t> cpus_ = {}; // in clock_set_rate event, it save cpu 584 std::deque<DataIndex> names_ = {}; 585 std::deque<DataIndex> types_ = {}; 586 }; 587 class ClkEventData : public CacheBase { 588 public: 589 size_t AppendNewFilter(uint64_t id, uint64_t rate, DataIndex name, uint64_t cpu); 590 NamesData()591 const std::deque<DataIndex>& NamesData() const 592 { 593 return names_; 594 } RatesData()595 const std::deque<uint64_t>& RatesData() const 596 { 597 return rates_; 598 } CpusData()599 const std::deque<uint64_t>& CpusData() const 600 { 601 return cpus_; 602 } Clear()603 void Clear() override 604 { 605 CacheBase::Clear(); 606 names_.clear(); 607 rates_.clear(); 608 cpus_.clear(); 609 } 610 611 private: 612 std::deque<DataIndex> names_; 613 std::deque<uint64_t> rates_; 614 std::deque<uint64_t> cpus_; 615 }; 616 class SysCall : public CacheBase { 617 public: 618 size_t AppendSysCallData(int64_t sysCallNum, DataIndex type, uint32_t ipid, uint64_t timeStamp, int64_t ret); SysCallsData()619 const std::deque<int64_t>& SysCallsData() const 620 { 621 return sysCallNums_; 622 } TypesData()623 const std::deque<DataIndex>& TypesData() const 624 { 625 return types_; 626 } IpidsData()627 const std::deque<uint32_t>& IpidsData() const 628 { 629 return ipids_; 630 } RetsData()631 const std::deque<uint64_t>& RetsData() const 632 { 633 return rets_; 634 } Clear()635 void Clear() override 636 { 637 CacheBase::Clear(); 638 sysCallNums_.clear(); 639 types_.clear(); 640 ipids_.clear(); 641 rets_.clear(); 642 } 643 644 private: 645 std::deque<int64_t> sysCallNums_ = {}; 646 std::deque<DataIndex> types_ = {}; 647 std::deque<uint32_t> ipids_ = {}; 648 std::deque<uint64_t> rets_ = {}; 649 }; 650 class ArgSet : public CacheBase { 651 public: 652 size_t AppendNewArg(DataIndex nameId, BaseDataType dataType, int64_t value, size_t argSet); 653 const std::deque<BaseDataType>& DataTypes() const; 654 const std::deque<int64_t>& ValuesData() const; 655 const std::deque<uint64_t>& ArgsData() const; 656 const std::deque<DataIndex>& NamesData() const; 657 Clear()658 void Clear() override 659 { 660 CacheBase::Clear(); 661 names_.clear(); 662 dataTypes_.clear(); 663 values_.clear(); 664 argset_.clear(); 665 } 666 667 private: 668 std::deque<uint64_t> names_ = {}; 669 std::deque<BaseDataType> dataTypes_ = {}; 670 std::deque<int64_t> values_ = {}; 671 std::deque<uint64_t> argset_ = {}; 672 }; 673 class SysMeasureFilter : public CacheBase { 674 public: 675 size_t AppendNewFilter(uint64_t filterId, DataIndex type, DataIndex nameId); 676 const std::deque<DataIndex>& NamesData() const; 677 const std::deque<DataIndex>& TypesData() const; Clear()678 void Clear() override 679 { 680 CacheBase::Clear(); 681 types_.clear(); 682 names_.clear(); 683 } 684 685 private: 686 std::deque<DataIndex> types_ = {}; 687 std::deque<DataIndex> names_ = {}; 688 }; 689 class DataType : public CacheBase { 690 public: 691 size_t AppendNewDataType(BaseDataType dataType, DataIndex dataDescIndex); 692 const std::deque<BaseDataType>& DataTypes() const; 693 const std::deque<DataIndex>& DataDesc() const; Clear()694 void Clear() override 695 { 696 CacheBase::Clear(); 697 dataTypes_.clear(); 698 descs_.clear(); 699 } 700 701 private: 702 std::deque<BaseDataType> dataTypes_ = {}; 703 std::deque<DataIndex> descs_ = {}; 704 }; 705 class LogInfo : public CacheBase { 706 public: 707 size_t AppendNewLogInfo(uint64_t seq, 708 uint64_t timeStamp, 709 uint32_t pid, 710 uint32_t tid, 711 DataIndex level, 712 DataIndex tag, 713 DataIndex context, 714 uint64_t originTs); 715 const std::deque<uint64_t>& HilogLineSeqs() const; 716 const std::deque<uint32_t>& Pids() const; 717 const std::deque<uint32_t>& Tids() const; 718 const std::deque<DataIndex>& Levels() const; 719 const std::deque<DataIndex>& Tags() const; 720 const std::deque<DataIndex>& Contexts() const; 721 const std::deque<uint64_t>& OriginTimeStamData() const; Clear()722 void Clear() override 723 { 724 CacheBase::Clear(); 725 hilogLineSeqs_.clear(); 726 pids_.clear(); 727 levels_.clear(); 728 tags_.clear(); 729 contexts_.clear(); 730 originTs_.clear(); 731 } 732 733 private: 734 std::deque<uint64_t> hilogLineSeqs_ = {}; 735 std::deque<uint32_t> pids_ = {}; 736 std::deque<uint32_t> tids_ = {}; 737 std::deque<DataIndex> levels_ = {}; 738 std::deque<DataIndex> tags_ = {}; 739 std::deque<DataIndex> contexts_ = {}; 740 std::deque<uint64_t> originTs_ = {}; 741 }; 742 743 class NativeHook : public CacheBase { 744 public: 745 size_t AppendNewNativeHookData(uint32_t callChainId, 746 uint32_t ipid, 747 uint32_t itid, 748 std::string eventType, 749 DataIndex subType, 750 uint64_t timeStamp, 751 uint64_t endTimeStamp, 752 uint64_t duration, 753 uint64_t addr, 754 int64_t memSize); 755 void UpdateCallChainId(size_t row, uint32_t callChainId); 756 void UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp); 757 void UpdateCurrentSizeDur(size_t row, uint64_t timeStamp); 758 void UpdateMemMapSubType(uint64_t row, uint64_t tagId); 759 void UpdateLastCallerPathIndexs(std::unordered_map<uint32_t, uint64_t>& callIdToLasLibId); 760 const std::deque<uint32_t>& CallChainIds() const; 761 const std::deque<uint32_t>& Ipids() const; 762 const std::deque<uint32_t>& Itids() const; 763 const std::deque<std::string>& EventTypes() const; 764 const std::deque<DataIndex>& SubTypes() const; 765 const std::deque<uint64_t>& EndTimeStamps() const; 766 const std::deque<uint64_t>& Durations() const; 767 const std::deque<uint64_t>& Addrs() const; 768 const std::deque<int64_t>& MemSizes() const; 769 const std::deque<int64_t>& AllMemSizes() const; 770 const std::deque<uint64_t>& CurrentSizeDurs() const; 771 const std::deque<uint64_t>& LastCallerPathIndexs() const; Clear()772 void Clear() override 773 { 774 CacheBase::Clear(); 775 callChainIds_.clear(); 776 ipids_.clear(); 777 itids_.clear(); 778 eventTypes_.clear(); 779 subTypes_.clear(); 780 endTimeStamps_.clear(); 781 durations_.clear(); 782 addrs_.clear(); 783 memSizes_.clear(); 784 allMemSizes_.clear(); 785 currentSizeDurs_.clear(); 786 lastCallerPathIndexs_.clear(); 787 } 788 789 private: 790 std::deque<uint32_t> callChainIds_ = {}; 791 std::deque<uint32_t> ipids_ = {}; 792 std::deque<uint32_t> itids_ = {}; 793 std::deque<std::string> eventTypes_ = {}; 794 std::deque<DataIndex> subTypes_ = {}; 795 std::deque<uint64_t> endTimeStamps_ = {}; 796 std::deque<uint64_t> durations_ = {}; 797 std::deque<uint64_t> addrs_ = {}; 798 std::deque<int64_t> memSizes_ = {}; 799 std::deque<int64_t> allMemSizes_ = {}; 800 std::deque<uint64_t> currentSizeDurs_ = {}; 801 std::deque<uint64_t> lastCallerPathIndexs_ = {}; 802 int64_t countHeapSizes_ = 0; 803 int64_t countMmapSizes_ = 0; 804 const std::string ALLOC_EVET = "AllocEvent"; 805 const std::string FREE_EVENT = "FreeEvent"; 806 const std::string MMAP_EVENT = "MmapEvent"; 807 const std::string MUNMAP_EVENT = "MunmapEvent"; 808 }; 809 810 class NativeHookFrame { 811 public: 812 size_t AppendNewNativeHookFrame(uint32_t callChainId, 813 uint64_t depth, 814 uint64_t ip, 815 uint64_t sp, 816 DataIndex symbolName, 817 DataIndex filePath, 818 uint64_t offset, 819 uint64_t symbolOffset); 820 size_t AppendNewNativeHookFrame(uint32_t callChainId, 821 uint64_t depth, 822 uint64_t ip, 823 uint64_t sp, 824 DataIndex symbolName, 825 DataIndex filePath, 826 uint64_t offset, 827 uint64_t symbolOffset, 828 const std::string& vaddr); 829 void UpdateFrameInfo(size_t row, 830 DataIndex symbolIndex, 831 DataIndex filePathIndex, 832 uint64_t offset, 833 uint64_t symbolOffset); 834 void UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId); 835 void UpdateSymbolId(); 836 void UpdateSymbolId(size_t index, DataIndex symbolId); 837 void UpdateFileId(std::map<uint32_t, uint64_t>& filePathIdToFilePathName); 838 void UpdateVaddrs(std::deque<std::string>& vaddrs); 839 const std::deque<uint32_t>& CallChainIds() const; 840 const std::deque<uint64_t>& Depths() const; 841 const std::deque<uint64_t>& Ips() const; 842 const std::deque<uint64_t>& Sps() const; 843 const std::deque<DataIndex>& SymbolNames() const; 844 const std::deque<DataIndex>& FilePaths() const; 845 const std::deque<uint64_t>& Offsets() const; 846 const std::deque<uint64_t>& SymbolOffsets() const; 847 const std::deque<std::string>& Vaddrs() const; Size()848 size_t Size() const 849 { 850 return callChainIds_.size(); 851 } Clear()852 void Clear() 853 { 854 callChainIds_.clear(); 855 depths_.clear(); 856 ips_.clear(); 857 sps_.clear(); 858 symbolNames_.clear(); 859 filePaths_.clear(); 860 offsets_.clear(); 861 symbolOffsets_.clear(); 862 vaddrs_.clear(); 863 } 864 865 private: 866 std::deque<uint32_t> callChainIds_ = {}; 867 std::deque<uint64_t> depths_ = {}; 868 std::deque<uint64_t> ips_ = {}; 869 std::deque<uint64_t> sps_ = {}; 870 std::deque<DataIndex> symbolNames_ = {}; 871 std::deque<DataIndex> filePaths_ = {}; 872 std::deque<uint64_t> offsets_ = {}; 873 std::deque<uint64_t> symbolOffsets_ = {}; 874 std::deque<std::string> vaddrs_ = {}; 875 std::map<uint32_t, uint64_t> symbolIdToSymbolName_ = {}; 876 }; 877 878 class NativeHookStatistic : public CacheBase { 879 public: 880 size_t AppendNewNativeHookStatistic(uint32_t ipid, 881 uint64_t timeStamp, 882 uint32_t callChainId, 883 uint32_t memoryType, 884 DataIndex subMemType, 885 uint64_t applyCount, 886 uint64_t releaseCount, 887 uint64_t applySize, 888 uint64_t releaseSize); 889 890 const std::deque<uint32_t>& Ipids() const; 891 const std::deque<uint32_t>& CallChainIds() const; 892 const std::deque<uint32_t>& MemoryTypes() const; 893 const std::deque<DataIndex>& MemorySubTypes() const; 894 const std::deque<uint64_t>& ApplyCounts() const; 895 const std::deque<uint64_t>& ReleaseCounts() const; 896 const std::deque<uint64_t>& ApplySizes() const; 897 const std::deque<uint64_t>& ReleaseSizes() const; Clear()898 void Clear() override 899 { 900 CacheBase::Clear(); 901 ids_.clear(); 902 ipids_.clear(); 903 callChainIds_.clear(); 904 timeStamps_.clear(); 905 memoryTypes_.clear(); 906 applyCounts_.clear(); 907 releaseCounts_.clear(); 908 applySizes_.clear(); 909 releaseSizes_.clear(); 910 } 911 912 private: 913 std::deque<uint32_t> ipids_ = {}; 914 std::deque<uint32_t> callChainIds_ = {}; 915 std::deque<uint32_t> memoryTypes_ = {}; 916 std::deque<DataIndex> memSubTypes_ = {}; 917 std::deque<uint64_t> applyCounts_ = {}; 918 std::deque<uint64_t> releaseCounts_ = {}; 919 std::deque<uint64_t> applySizes_ = {}; 920 std::deque<uint64_t> releaseSizes_ = {}; 921 }; 922 923 class Hidump : public CacheBase { 924 public: 925 size_t AppendNewHidumpInfo(uint64_t timeStamp, uint32_t fps); 926 const std::deque<uint32_t>& Fpss() const; 927 928 private: 929 std::deque<uint32_t> fpss_ = {}; 930 }; 931 932 class PerfCallChain : public CacheBase { 933 public: 934 size_t AppendNewPerfCallChain(uint64_t sampleId, 935 uint32_t callChainId, 936 uint64_t vaddrInFile, 937 uint64_t fileId, 938 uint64_t symbolId); 939 const std::deque<uint64_t>& SampleIds() const; 940 const std::deque<uint32_t>& CallChainIds() const; 941 const std::deque<uint64_t>& VaddrInFiles() const; 942 const std::deque<uint64_t>& FileIds() const; 943 const std::deque<uint64_t>& SymbolIds() const; 944 const std::deque<std::string>& Names() const; 945 void SetName(uint64_t index, const std::string& name); 946 void Clear() override; 947 948 private: 949 std::deque<uint64_t> sampleIds_ = {}; 950 std::deque<uint32_t> callChainIds_ = {}; 951 std::deque<uint64_t> vaddrInFiles_ = {}; 952 std::deque<uint64_t> fileIds_ = {}; 953 std::deque<uint64_t> symbolIds_ = {}; 954 std::deque<std::string> names_ = {}; 955 }; 956 957 class PerfFiles : public CacheBase { 958 public: 959 size_t AppendNewPerfFiles(uint64_t fileIds, uint32_t serial, DataIndex symbols, DataIndex filePath); 960 const std::deque<uint64_t>& FileIds() const; 961 const std::deque<DataIndex>& Symbols() const; 962 const std::deque<DataIndex>& FilePaths() const; 963 const std::deque<uint32_t>& Serials() const; 964 void Clear() override; 965 966 private: 967 std::deque<uint64_t> fileIds_ = {}; 968 std::deque<uint32_t> serials_ = {}; 969 std::deque<DataIndex> symbols_ = {}; 970 std::deque<DataIndex> filePaths_ = {}; 971 }; 972 973 class PerfSample : public CacheBase { 974 public: 975 size_t AppendNewPerfSample(uint32_t sampleId, 976 uint64_t timeStamp, 977 uint32_t tid, 978 uint64_t eventCount, 979 uint64_t eventTypeId, 980 uint64_t timestampTrace, 981 uint64_t cpuId, 982 uint64_t threadState); 983 const std::deque<uint32_t>& SampleIds() const; 984 const std::deque<uint32_t>& Tids() const; 985 const std::deque<uint64_t>& EventCounts() const; 986 const std::deque<uint64_t>& EventTypeIds() const; 987 const std::deque<uint64_t>& TimestampTraces() const; 988 const std::deque<uint64_t>& CpuIds() const; 989 const std::deque<DataIndex>& ThreadStates() const; 990 void Clear() override; 991 992 private: 993 std::deque<uint32_t> sampleIds_ = {}; 994 std::deque<uint32_t> tids_ = {}; 995 std::deque<uint64_t> eventCounts_ = {}; 996 std::deque<uint64_t> eventTypeIds_ = {}; 997 std::deque<uint64_t> timestampTraces_ = {}; 998 std::deque<uint64_t> cpuIds_ = {}; 999 std::deque<DataIndex> threadStates_ = {}; 1000 }; 1001 1002 class PerfThread : public CacheBase { 1003 public: 1004 size_t AppendNewPerfThread(uint32_t pid, uint32_t tid, DataIndex threadName); 1005 const std::deque<uint32_t>& Pids() const; 1006 const std::deque<uint32_t>& Tids() const; 1007 const std::deque<DataIndex>& ThreadNames() const; 1008 void Clear() override; 1009 1010 private: 1011 std::deque<uint32_t> tids_ = {}; 1012 std::deque<uint32_t> pids_ = {}; 1013 std::deque<DataIndex> threadNames_ = {}; 1014 }; 1015 1016 class PerfReport : public CacheBase { 1017 public: 1018 size_t AppendNewPerfReport(DataIndex type, DataIndex value); 1019 const std::deque<DataIndex>& Types() const; 1020 const std::deque<DataIndex>& Values() const; 1021 1022 private: 1023 std::deque<DataIndex> types_ = {}; 1024 std::deque<DataIndex> values_ = {}; 1025 }; 1026 class StatAndInfo { 1027 public: 1028 StatAndInfo(); 1029 ~StatAndInfo() = default; 1030 void IncreaseStat(SupportedTraceEventType eventType, StatType type); 1031 const uint32_t& GetValue(SupportedTraceEventType eventType, StatType type) const; 1032 const std::string& GetEvent(SupportedTraceEventType eventType) const; 1033 const std::string& GetStat(StatType type) const; 1034 const std::string& GetSeverityDesc(SupportedTraceEventType eventType, StatType type) const; 1035 const StatSeverityLevel& GetSeverity(SupportedTraceEventType eventType, StatType type) const; 1036 std::map<BuiltinClocks, std::string> clockid2ClockNameMap_ = {}; 1037 1038 private: 1039 uint32_t statCount_[TRACE_EVENT_MAX][STAT_EVENT_MAX]; 1040 std::string event_[TRACE_EVENT_MAX]; 1041 std::string stat_[STAT_EVENT_MAX]; 1042 std::string statSeverityDesc_[TRACE_EVENT_MAX][STAT_EVENT_MAX]; 1043 StatSeverityLevel statSeverity_[TRACE_EVENT_MAX][STAT_EVENT_MAX]; 1044 TraceStreamerConfig config_{}; 1045 }; 1046 class SymbolsData { 1047 public: 1048 SymbolsData() = default; 1049 ~SymbolsData() = default; 1050 uint64_t Size() const; 1051 void InsertSymbol(const DataIndex& name, const uint64_t& addr); 1052 const std::deque<DataIndex>& GetConstFuncNames() const; 1053 const std::deque<uint64_t>& GetConstAddrs() const; Clear()1054 void Clear() 1055 { 1056 addrs_.clear(); 1057 funcName_.clear(); 1058 } 1059 1060 private: 1061 std::deque<uint64_t> addrs_ = {}; 1062 std::deque<DataIndex> funcName_ = {}; 1063 }; 1064 class DiskIOData : public CacheBase { 1065 public: 1066 DiskIOData() = default; 1067 ~DiskIOData() = default; 1068 void AppendNewData(uint64_t ts, 1069 uint64_t dur, 1070 uint64_t rd, 1071 uint64_t wr, 1072 uint64_t rdPerSec, 1073 uint64_t wrPerSec, 1074 double rdCountPerSec, 1075 double wrCountPerSec, 1076 uint64_t rdCount, 1077 uint64_t wrCount); 1078 const std::deque<uint64_t>& Durs() const; 1079 const std::deque<uint64_t>& RdDatas() const; 1080 const std::deque<uint64_t>& WrDatas() const; 1081 const std::deque<double>& RdSpeedDatas() const; 1082 const std::deque<double>& WrSpeedDatas() const; 1083 const std::deque<double>& RdCountPerSecDatas() const; 1084 const std::deque<double>& WrCountPerSecDatas() const; 1085 const std::deque<uint64_t>& RdCountDatas() const; 1086 const std::deque<uint64_t>& WrCountDatas() const; 1087 1088 private: 1089 std::deque<uint64_t> durs_ = {}; 1090 std::deque<uint64_t> rdDatas_ = {}; 1091 std::deque<uint64_t> wrDatas_ = {}; 1092 std::deque<double> wrPerSec_ = {}; 1093 std::deque<double> rdPerSec_ = {}; 1094 std::deque<double> wrCountPerSec_ = {}; 1095 std::deque<double> rdCountPerSec_ = {}; 1096 std::deque<uint64_t> rdCountDatas_ = {}; 1097 std::deque<uint64_t> wrCountDatas_ = {}; 1098 }; 1099 class MetaData { 1100 public: 1101 MetaData(); 1102 ~MetaData() = default; 1103 void SetTraceType(const std::string& traceType); 1104 void SetSourceFileName(const std::string& fileName); 1105 void SetOutputFileName(const std::string& fileName); 1106 void SetParserToolVersion(const std::string& version); 1107 void SetParserToolPublishDateTime(const std::string& datetime); 1108 void SetTraceDataSize(uint64_t dataSize); 1109 void SetTraceDuration(uint64_t dur); 1110 const std::string& Value(uint64_t row) const; 1111 const std::string& Name(uint64_t row) const; Clear()1112 void Clear() 1113 { 1114 columnNames_.clear(); 1115 values_.clear(); 1116 } 1117 1118 private: 1119 const std::string METADATA_ITEM_DATASIZE_COLNAME = "datasize"; 1120 const std::string METADATA_ITEM_PARSETOOL_NAME_COLNAME = "parse_tool"; 1121 const std::string METADATA_ITEM_PARSERTOOL_VERSION_COLNAME = "tool_version"; 1122 const std::string METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME_COLNAME = "tool_publish_time"; 1123 const std::string METADATA_ITEM_SOURCE_FILENAME_COLNAME = "source_name"; 1124 const std::string METADATA_ITEM_OUTPUT_FILENAME_COLNAME = "output_name"; 1125 const std::string METADATA_ITEM_PARSERTIME_COLNAME = "runtime"; 1126 const std::string METADATA_ITEM_TRACE_DURATION_COLNAME = "trace_duration"; 1127 const std::string METADATA_ITEM_SOURCE_DATETYPE_COLNAME = "source_type"; 1128 1129 std::deque<std::string> columnNames_ = {}; 1130 std::deque<std::string> values_ = {}; 1131 }; 1132 class DataDict { 1133 public: Size()1134 size_t Size() const 1135 { 1136 return dataDict_.size(); 1137 } 1138 DataIndex GetStringIndex(std::string_view str); 1139 DataIndex GetStringIndexNoWrite(std::string_view str) const; GetDataFromDict(DataIndex id)1140 const std::string& GetDataFromDict(DataIndex id) const 1141 { 1142 TS_ASSERT(id < dataDict_.size()); 1143 return dataDict_[id]; 1144 } 1145 void Finish(); Clear()1146 void Clear() 1147 { 1148 dataDict_.clear(); 1149 } 1150 1151 public: 1152 std::deque<std::string> dataDict_; 1153 std::unordered_map<uint64_t, DataIndex> dataDictInnerMap_; 1154 1155 private: 1156 std::hash<std::string_view> hashFun; 1157 std::mutex mutex_; 1158 const int8_t SPASCII_START = 0; 1159 const int8_t SPASCII_END = 32; 1160 }; 1161 class NetDetailData : public CacheBase { 1162 public: 1163 size_t AppendNewNetData(uint64_t newTimeStamp, 1164 uint64_t tx, 1165 uint64_t rx, 1166 uint64_t dur, 1167 double rxSpeed, 1168 double txSpeed, 1169 uint64_t packetIn, 1170 double packetInSec, 1171 uint64_t packetOut, 1172 double packetOutSec, 1173 const std::string& netType); 1174 const std::deque<uint64_t>& Durs() const; 1175 const std::deque<double>& RxSpeed() const; 1176 const std::deque<double>& TxSpeed() const; 1177 const std::deque<std::string>& NetTypes() const; 1178 const std::deque<uint64_t>& RxDatas() const; 1179 const std::deque<uint64_t>& TxDatas() const; 1180 const std::deque<uint64_t>& PacketIn() const; 1181 const std::deque<double>& PacketInSec() const; 1182 const std::deque<uint64_t>& PacketOut() const; 1183 const std::deque<double>& PacketOutSec() const; Clear()1184 void Clear() override 1185 { 1186 CacheBase::Clear(); 1187 durs_.clear(); 1188 rxSpeeds_.clear(); 1189 txSpeeds_.clear(); 1190 netTypes_.clear(); 1191 packetIn_.clear(); 1192 packetInSec_.clear(); 1193 packetOut_.clear(); 1194 packetOutSec_.clear(); 1195 } 1196 1197 private: 1198 std::deque<uint64_t> rxs_ = {}; 1199 std::deque<uint64_t> txs_ = {}; 1200 std::deque<uint64_t> durs_ = {}; 1201 std::deque<double> rxSpeeds_ = {}; 1202 std::deque<double> txSpeeds_ = {}; 1203 std::deque<uint64_t> packetIn_ = {}; 1204 std::deque<double> packetInSec_ = {}; 1205 std::deque<uint64_t> packetOut_ = {}; 1206 std::deque<double> packetOutSec_ = {}; 1207 std::deque<std::string> netTypes_ = {}; 1208 }; 1209 class LiveProcessDetailData : public CacheBase { 1210 public: 1211 size_t AppendNewData(uint64_t newTimeStamp, 1212 uint64_t dur, 1213 int32_t processID, 1214 std::string processName, 1215 int32_t parentProcessID, 1216 int32_t uid, 1217 std::string userName, 1218 double cpuUsage, 1219 int32_t pssInfo, 1220 uint64_t cpuTime, 1221 int32_t threads, 1222 int64_t diskWrites, 1223 int64_t diskReads); 1224 const std::deque<uint64_t>& Durs() const; 1225 const std::deque<int32_t>& ProcessID() const; 1226 const std::deque<std::string>& ProcessName() const; 1227 const std::deque<int32_t>& ParentProcessID() const; 1228 const std::deque<int32_t>& Uid() const; 1229 const std::deque<std::string>& UserName() const; 1230 const std::deque<double>& CpuUsage() const; 1231 const std::deque<int32_t>& PssInfo() const; 1232 const std::deque<int32_t>& Threads() const; 1233 const std::deque<int64_t>& DiskWrites() const; 1234 const std::deque<int64_t>& DiskReads() const; 1235 const std::deque<uint64_t>& CpuTimes() const; Clear()1236 void Clear() override 1237 { 1238 CacheBase::Clear(); 1239 durs_.clear(); 1240 processID_.clear(); 1241 processName_.clear(); 1242 parentProcessID_.clear(); 1243 uid_.clear(); 1244 userName_.clear(); 1245 cpuUsage_.clear(); 1246 pssInfo_.clear(); 1247 threads_.clear(); 1248 diskWrites_.clear(); 1249 diskReads_.clear(); 1250 } 1251 1252 private: 1253 std::deque<uint64_t> durs_ = {}; 1254 std::deque<int32_t> processID_ = {}; 1255 std::deque<std::string> processName_ = {}; 1256 std::deque<int32_t> parentProcessID_ = {}; 1257 std::deque<int32_t> uid_ = {}; 1258 std::deque<std::string> userName_ = {}; 1259 std::deque<double> cpuUsage_ = {}; 1260 std::deque<int32_t> pssInfo_ = {}; 1261 std::deque<int32_t> threads_ = {}; 1262 std::deque<int64_t> diskWrites_ = {}; 1263 std::deque<int64_t> diskReads_ = {}; 1264 std::deque<uint64_t> cpuTimes_ = {}; 1265 }; 1266 class CpuUsageDetailData : public CacheBase { 1267 public: 1268 size_t AppendNewData(uint64_t newTimeStamp, 1269 uint64_t dur, 1270 double totalLoad, 1271 double userLoad, 1272 double systemLoad, 1273 int64_t threads); 1274 const std::deque<uint64_t>& Durs() const; 1275 const std::deque<double>& TotalLoad() const; 1276 const std::deque<double>& UserLoad() const; 1277 const std::deque<double>& SystemLoad() const; 1278 const std::deque<int64_t>& Threads() const; Clear()1279 void Clear() override 1280 { 1281 CacheBase::Clear(); 1282 durs_.clear(); 1283 totalLoad_.clear(); 1284 userLoad_.clear(); 1285 systemLoad_.clear(); 1286 threads_.clear(); 1287 } 1288 1289 private: 1290 std::deque<uint64_t> durs_ = {}; 1291 std::deque<double> totalLoad_ = {}; 1292 std::deque<double> userLoad_ = {}; 1293 std::deque<double> systemLoad_ = {}; 1294 std::deque<int64_t> threads_ = {}; 1295 }; 1296 class FileSystemSample : public CacheBase { 1297 public: 1298 size_t AppendNewData(uint32_t callChainId, 1299 uint16_t type, 1300 uint32_t ipid, 1301 uint32_t itid, 1302 uint64_t startTs, 1303 uint64_t endTs, 1304 uint64_t dur, 1305 DataIndex returnValue, 1306 DataIndex errorCode, 1307 size_t size, 1308 int32_t fd, 1309 DataIndex fileId, 1310 DataIndex firstArgument, 1311 DataIndex secondArgument, 1312 DataIndex thirdArgument, 1313 DataIndex fourthArgument); 1314 const std::deque<uint32_t>& CallChainIds() const; 1315 const std::deque<uint16_t>& Types() const; 1316 const std::deque<uint32_t>& Ipids() const; 1317 const std::deque<uint32_t>& Itids() const; 1318 const std::deque<uint64_t>& StartTs() const; 1319 const std::deque<uint64_t>& EndTs() const; 1320 const std::deque<uint64_t>& Durs() const; 1321 const std::deque<DataIndex>& ReturnValues() const; 1322 const std::deque<DataIndex>& ErrorCodes() const; 1323 const std::deque<int32_t>& Fds() const; 1324 const std::deque<DataIndex>& FileIds() const; 1325 const std::deque<size_t>& Sizes() const; 1326 const std::deque<DataIndex>& FirstArguments() const; 1327 const std::deque<DataIndex>& SecondArguments() const; 1328 const std::deque<DataIndex>& ThirdArguments() const; 1329 const std::deque<DataIndex>& FourthArguments() const; Clear()1330 void Clear() override 1331 { 1332 CacheBase::Clear(); 1333 callChainIds_.clear(); 1334 types_.clear(); 1335 ipids_.clear(); 1336 itids_.clear(); 1337 startTs_.clear(); 1338 endTs_.clear(); 1339 durs_.clear(); 1340 returnValues_.clear(); 1341 errorCodes_.clear(); 1342 fds_.clear(); 1343 Sizes_.clear(); 1344 firstArguments_.clear(); 1345 secondArguments_.clear(); 1346 thirdArguments_.clear(); 1347 fourthArguments_.clear(); 1348 } 1349 1350 private: 1351 std::deque<uint32_t> callChainIds_ = {}; 1352 std::deque<uint16_t> types_ = {}; 1353 std::deque<uint32_t> ipids_ = {}; 1354 std::deque<uint32_t> itids_ = {}; 1355 std::deque<uint64_t> startTs_ = {}; 1356 std::deque<uint64_t> endTs_ = {}; 1357 std::deque<uint64_t> durs_ = {}; 1358 std::deque<DataIndex> returnValues_ = {}; 1359 std::deque<DataIndex> errorCodes_ = {}; 1360 std::deque<int32_t> fds_ = {}; 1361 std::deque<DataIndex> fileIds_ = {}; 1362 std::deque<size_t> Sizes_ = {}; 1363 std::deque<DataIndex> firstArguments_ = {}; 1364 std::deque<DataIndex> secondArguments_ = {}; 1365 std::deque<DataIndex> thirdArguments_ = {}; 1366 std::deque<DataIndex> fourthArguments_ = {}; 1367 }; 1368 class EbpfCallStackData : public CacheBase { 1369 public: 1370 size_t AppendNewData(uint32_t callChainId, uint32_t depth, DataIndex ip, DataIndex symbolId, DataIndex filePathId); 1371 void UpdateSymbolAndFilePathIndex(size_t row, DataIndex symbolId, DataIndex filePathId); 1372 const std::deque<uint32_t>& CallChainIds() const; 1373 const std::deque<uint32_t>& Depths() const; 1374 const std::deque<DataIndex>& Ips() const; 1375 const std::deque<DataIndex>& SymbolIds() const; 1376 const std::deque<DataIndex>& FilePathIds() const; Clear()1377 void Clear() override 1378 { 1379 CacheBase::Clear(); 1380 callChainIds_.clear(); 1381 depths_.clear(); 1382 symbolIds_.clear(); 1383 filePathIds_.clear(); 1384 } 1385 1386 private: 1387 std::deque<uint32_t> callChainIds_ = {}; 1388 std::deque<uint32_t> depths_ = {}; 1389 std::deque<DataIndex> ips_ = {}; 1390 std::deque<DataIndex> symbolIds_ = {}; 1391 std::deque<DataIndex> filePathIds_ = {}; 1392 }; 1393 class PagedMemorySampleData : public CacheBase { 1394 public: 1395 size_t AppendNewData(uint32_t callChainId, 1396 uint16_t type, 1397 uint32_t ipid, 1398 uint64_t startTs, 1399 uint64_t endTs, 1400 uint64_t dur, 1401 size_t size, 1402 DataIndex addr, 1403 uint32_t itid); 1404 const std::deque<uint32_t>& CallChainIds() const; 1405 const std::deque<uint16_t>& Types() const; 1406 const std::deque<uint32_t>& Ipids() const; 1407 const std::deque<uint64_t>& StartTs() const; 1408 const std::deque<uint64_t>& EndTs() const; 1409 const std::deque<uint64_t>& Durs() const; 1410 const std::deque<size_t>& Sizes() const; 1411 const std::deque<DataIndex>& Addr() const; 1412 const std::deque<uint32_t>& Itids() const; Clear()1413 void Clear() override 1414 { 1415 CacheBase::Clear(); 1416 callChainIds_.clear(); 1417 types_.clear(); 1418 ipids_.clear(); 1419 startTs_.clear(); 1420 endTs_.clear(); 1421 durs_.clear(); 1422 Sizes_.clear(); 1423 addrs_.clear(); 1424 itids_.clear(); 1425 } 1426 1427 private: 1428 std::deque<uint32_t> callChainIds_ = {}; 1429 std::deque<uint16_t> types_ = {}; 1430 std::deque<uint32_t> ipids_ = {}; 1431 std::deque<uint64_t> startTs_ = {}; 1432 std::deque<uint64_t> endTs_ = {}; 1433 std::deque<uint64_t> durs_ = {}; 1434 std::deque<size_t> Sizes_ = {}; 1435 std::deque<DataIndex> addrs_ = {}; 1436 std::deque<uint32_t> itids_ = {}; 1437 }; 1438 #if WITH_EBPF_HELP 1439 class EbpfProcessMaps : public CacheBase { 1440 public: 1441 size_t AppendNewData(uint64_t start, 1442 uint64_t end, 1443 uint32_t offset, 1444 uint32_t pid, 1445 uint32_t fileNameLen, 1446 uint64_t fileNameIndex); 1447 const std::deque<uint64_t>& Starts() const; 1448 const std::deque<uint64_t>& Ends() const; 1449 const std::deque<uint32_t>& Offsets() const; 1450 const std::deque<uint32_t>& Pids() const; 1451 const std::deque<uint32_t>& FileNameLens() const; 1452 const std::deque<uint64_t>& FileNameIndexs() const; Clear()1453 void Clear() override 1454 { 1455 CacheBase::Clear(); 1456 starts_.clear(); 1457 ends_.clear(); 1458 offsets_.clear(); 1459 pids_.clear(); 1460 fileNameLens_.clear(); 1461 fileNameIndexs_.clear(); 1462 } 1463 1464 private: 1465 std::deque<uint64_t> starts_ = {}; 1466 std::deque<uint64_t> ends_ = {}; 1467 std::deque<uint32_t> offsets_ = {}; 1468 std::deque<uint32_t> pids_ = {}; 1469 std::deque<uint32_t> fileNameLens_ = {}; 1470 std::deque<uint64_t> fileNameIndexs_ = {}; 1471 }; 1472 1473 class EbpfElf : public CacheBase { 1474 public: 1475 size_t AppendNewData(uint64_t elfId, 1476 uint64_t textVaddr, 1477 uint32_t textOffset, 1478 uint32_t strTabLen, 1479 uint32_t symTabLen, 1480 uint32_t fileNameLen, 1481 uint32_t symEntLen, 1482 uint64_t fileNameIndex); 1483 const std::deque<uint64_t>& ElfIds() const; 1484 const std::deque<uint64_t>& TextVaddrs() const; 1485 const std::deque<uint32_t>& TextOffsets() const; 1486 const std::deque<uint32_t>& StrTabLens() const; 1487 const std::deque<uint32_t>& SymTabLens() const; 1488 const std::deque<uint32_t>& FileNameLens() const; 1489 const std::deque<uint32_t>& SymEntLens() const; 1490 const std::deque<uint64_t>& FileNameIndexs() const; 1491 Clear()1492 void Clear() override 1493 { 1494 CacheBase::Clear(); 1495 elfIds_.clear(); 1496 textVaddrs_.clear(); 1497 textOffsets_.clear(); 1498 strTabLens_.clear(); 1499 symTabLens_.clear(); 1500 fileNameLens_.clear(); 1501 symEntLens_.clear(); 1502 fileNameIndexs_.clear(); 1503 } 1504 1505 private: 1506 std::deque<uint64_t> elfIds_ = {}; 1507 std::deque<uint64_t> textVaddrs_ = {}; 1508 std::deque<uint32_t> textOffsets_ = {}; 1509 std::deque<uint32_t> strTabLens_ = {}; 1510 std::deque<uint32_t> symTabLens_ = {}; 1511 std::deque<uint32_t> fileNameLens_ = {}; 1512 std::deque<uint32_t> symEntLens_ = {}; 1513 std::deque<uint64_t> fileNameIndexs_ = {}; 1514 }; 1515 1516 class EbpfElfSymbol : public CacheBase { 1517 public: 1518 size_t AppendNewData(uint64_t elfId, uint32_t stName, uint64_t stValue, uint64_t stSize); 1519 const std::deque<uint64_t>& ElfIds() const; 1520 const std::deque<uint32_t>& StNames() const; 1521 const std::deque<uint64_t>& StValues() const; 1522 const std::deque<uint64_t>& StSizes() const; 1523 Clear()1524 void Clear() override 1525 { 1526 CacheBase::Clear(); 1527 elfIds_.clear(); 1528 stNames_.clear(); 1529 stValues_.clear(); 1530 stSizes_.clear(); 1531 } 1532 1533 private: 1534 std::deque<uint64_t> elfIds_ = {}; 1535 std::deque<uint32_t> stNames_ = {}; 1536 std::deque<uint64_t> stValues_ = {}; 1537 std::deque<uint64_t> stSizes_ = {}; 1538 }; 1539 #endif 1540 class AppNames : public CacheBase { 1541 public: 1542 uint32_t AppendAppName(uint8_t flags, DataIndex eventSource, DataIndex appName); 1543 const std::deque<uint8_t>& Falgs() const; 1544 const std::deque<DataIndex>& EventSourceId() const; 1545 const std::deque<DataIndex>& AppName() const; Clear()1546 void Clear() override 1547 { 1548 CacheBase::Clear(); 1549 flags_.clear(); 1550 appNames_.clear(); 1551 keyNames_.clear(); 1552 } 1553 1554 private: 1555 std::deque<uint8_t> flags_ = {}; 1556 std::deque<DataIndex> appNames_ = {}; 1557 std::deque<DataIndex> keyNames_ = {}; 1558 }; 1559 class SysEventMeasureData : public CacheBase { 1560 public: 1561 void AppendData(uint64_t serial, 1562 uint64_t ts, 1563 uint32_t nameId, 1564 uint32_t keyId, 1565 int32_t type, 1566 double numericValue, 1567 DataIndex stringValue); 1568 const std::deque<uint64_t>& Serial() const; 1569 const std::deque<uint64_t>& Ts() const; 1570 const std::deque<uint32_t>& NameFilterId() const; 1571 const std::deque<uint32_t>& AppKeyFilterId() const; 1572 const std::deque<int32_t>& Type() const; 1573 const std::deque<double>& NumValue() const; 1574 const std::deque<DataIndex>& StringValue() const; Clear()1575 void Clear() override 1576 { 1577 CacheBase::Clear(); 1578 serial_.clear(); 1579 ts_.clear(); 1580 nameFilterIds_.clear(); 1581 appKeyFilterIds_.clear(); 1582 types_.clear(); 1583 numValues_.clear(); 1584 stringValues_.clear(); 1585 } 1586 1587 private: 1588 std::deque<uint64_t> serial_ = {}; 1589 std::deque<uint64_t> ts_ = {}; 1590 std::deque<uint32_t> nameFilterIds_ = {}; 1591 std::deque<uint32_t> appKeyFilterIds_ = {}; 1592 std::deque<int32_t> types_ = {}; 1593 std::deque<double> numValues_ = {}; 1594 std::deque<DataIndex> stringValues_ = {}; 1595 uint32_t rowCount_ = 0; 1596 }; 1597 class DeviceStateData : public CacheBase { 1598 public: 1599 void AppendNewData(int32_t brightness, 1600 int32_t btState, 1601 int32_t location, 1602 int32_t wifi, 1603 int32_t streamDefault, 1604 int32_t voiceCall, 1605 int32_t music, 1606 int32_t streamRing, 1607 int32_t media, 1608 int32_t voiceAssistant, 1609 int32_t system, 1610 int32_t alarm, 1611 int32_t notification, 1612 int32_t btSco, 1613 int32_t enforcedAudible, 1614 int32_t streamDtmf, 1615 int32_t streamTts, 1616 int32_t accessibility, 1617 int32_t recording, 1618 int32_t streamAll); 1619 const std::deque<int32_t>& Brightness() const; 1620 const std::deque<int32_t>& BtState() const; 1621 const std::deque<int32_t>& Location() const; 1622 const std::deque<int32_t>& Wifi() const; 1623 const std::deque<int32_t>& StreamDefault() const; 1624 const std::deque<int32_t>& VoiceCall() const; 1625 const std::deque<int32_t>& Music() const; 1626 const std::deque<int32_t>& StreamRing() const; 1627 const std::deque<int32_t>& Media() const; 1628 const std::deque<int32_t>& VoiceAssistant() const; 1629 const std::deque<int32_t>& System() const; 1630 const std::deque<int32_t>& Alarm() const; 1631 const std::deque<int32_t>& Notification() const; 1632 const std::deque<int32_t>& BtSco() const; 1633 const std::deque<int32_t>& EnforcedAudible() const; 1634 const std::deque<int32_t>& StreamDtmf() const; 1635 const std::deque<int32_t>& StreamTts() const; 1636 const std::deque<int32_t>& Accessibility() const; 1637 const std::deque<int32_t>& Recording() const; 1638 const std::deque<int32_t>& StreamAll() const; Clear()1639 void Clear() override 1640 { 1641 CacheBase::Clear(); 1642 brightness_.clear(); 1643 btStates_.clear(); 1644 locations_.clear(); 1645 wifis_.clear(); 1646 streamDefaults_.clear(); 1647 voiceCalls_.clear(); 1648 musics_.clear(); 1649 streamRings_.clear(); 1650 medias_.clear(); 1651 voiceAssistants_.clear(); 1652 systems_.clear(); 1653 alarms_.clear(); 1654 notifications_.clear(); 1655 btScos_.clear(); 1656 enforcedAudibles_.clear(); 1657 streamDtmfs_.clear(); 1658 streamTts_.clear(); 1659 accessibilitys_.clear(); 1660 recordings_.clear(); 1661 streamAlls_.clear(); 1662 } 1663 1664 private: 1665 std::deque<uint32_t> stringValues_ = {}; 1666 std::deque<int32_t> brightness_ = {}; 1667 std::deque<int32_t> btStates_ = {}; 1668 std::deque<int32_t> locations_ = {}; 1669 std::deque<int32_t> wifis_ = {}; 1670 std::deque<int32_t> streamDefaults_ = {}; 1671 std::deque<int32_t> voiceCalls_ = {}; 1672 std::deque<int32_t> musics_ = {}; 1673 std::deque<int32_t> streamRings_ = {}; 1674 std::deque<int32_t> medias_ = {}; 1675 std::deque<int32_t> voiceAssistants_ = {}; 1676 std::deque<int32_t> systems_ = {}; 1677 std::deque<int32_t> alarms_ = {}; 1678 std::deque<int32_t> notifications_ = {}; 1679 std::deque<int32_t> btScos_ = {}; 1680 std::deque<int32_t> enforcedAudibles_ = {}; 1681 std::deque<int32_t> streamDtmfs_ = {}; 1682 std::deque<int32_t> streamTts_ = {}; 1683 std::deque<int32_t> accessibilitys_ = {}; 1684 std::deque<int32_t> recordings_ = {}; 1685 std::deque<int32_t> streamAlls_ = {}; 1686 uint32_t rowCounts_ = 0; 1687 }; 1688 class TraceConfigData : public CacheBase { 1689 public: 1690 void AppendNewData(std::string traceSource, std::string key, std::string value); 1691 const std::deque<std::string>& TraceSource() const; 1692 const std::deque<std::string>& Key() const; 1693 const std::deque<std::string>& Value() const; Clear()1694 void Clear() override 1695 { 1696 CacheBase::Clear(); 1697 traceSource_.clear(); 1698 key_.clear(); 1699 value_.clear(); 1700 } 1701 1702 private: 1703 std::deque<std::string> traceSource_ = {}; 1704 std::deque<std::string> key_ = {}; 1705 std::deque<std::string> value_ = {}; 1706 uint32_t rowCounts_ = 0; 1707 }; 1708 class SmapsData : public CacheBase { 1709 public: 1710 void AppendNewData(uint64_t timeStamp, 1711 uint64_t ipid, 1712 std::string startAddr, 1713 std::string endAddr, 1714 uint64_t dirty, 1715 uint64_t swapper, 1716 uint64_t rss, 1717 uint64_t pss, 1718 uint64_t size, 1719 double reside, 1720 DataIndex protectionId, 1721 DataIndex pathId, 1722 uint64_t shared_clean, 1723 uint64_t shared_dirty, 1724 uint64_t private_clean, 1725 uint64_t private_dirty, 1726 uint64_t swap, 1727 uint64_t swap_pss, 1728 uint32_t type); 1729 const std::deque<uint64_t>& Id() const; 1730 const std::deque<uint64_t>& TimeStamps() const; 1731 const std::deque<uint64_t>& Ipids() const; 1732 const std::deque<std::string>& StartAddrs() const; 1733 const std::deque<std::string>& EndAddrs() const; 1734 const std::deque<uint64_t>& Dirtys() const; 1735 const std::deque<uint64_t>& Swappers() const; 1736 const std::deque<uint64_t>& Rss() const; 1737 const std::deque<uint64_t>& Pss() const; 1738 const std::deque<uint64_t>& Sizes() const; 1739 const std::deque<double>& Resides() const; 1740 const std::deque<DataIndex>& ProtectionIds() const; 1741 const std::deque<DataIndex>& PathIds() const; 1742 const std::deque<uint64_t>& SharedClean() const; 1743 const std::deque<uint64_t>& SharedDirty() const; 1744 const std::deque<uint64_t>& PrivateClean() const; 1745 const std::deque<uint64_t>& PrivateDirty() const; 1746 const std::deque<uint64_t>& Swap() const; 1747 const std::deque<uint64_t>& SwapPss() const; 1748 const std::deque<uint32_t>& Type() const; Clear()1749 void Clear() override 1750 { 1751 CacheBase::Clear(); 1752 ipids_.clear(); 1753 startAddrs_.clear(); 1754 endAddrs_.clear(); 1755 dirtys_.clear(); 1756 swappers_.clear(); 1757 rss_.clear(); 1758 pss_.clear(); 1759 sizes_.clear(); 1760 resides_.clear(); 1761 protectionIds_.clear(); 1762 pathIds_.clear(); 1763 sharedClean_.clear(); 1764 sharedDirty_.clear(); 1765 privateClean_.clear(); 1766 privateDirty_.clear(); 1767 swap_.clear(); 1768 swapPss_.clear(); 1769 type_.clear(); 1770 } 1771 1772 private: 1773 std::deque<uint64_t> ipids_ = {}; 1774 std::deque<std::string> startAddrs_ = {}; 1775 std::deque<std::string> endAddrs_ = {}; 1776 std::deque<uint64_t> dirtys_ = {}; 1777 std::deque<uint64_t> swappers_ = {}; 1778 std::deque<uint64_t> rss_ = {}; 1779 std::deque<uint64_t> pss_ = {}; 1780 std::deque<uint64_t> sizes_ = {}; 1781 std::deque<double> resides_ = {}; 1782 std::deque<DataIndex> protectionIds_ = {}; 1783 std::deque<DataIndex> pathIds_ = {}; 1784 std::deque<uint64_t> sharedClean_ = {}; 1785 std::deque<uint64_t> sharedDirty_ = {}; 1786 std::deque<uint64_t> privateClean_ = {}; 1787 std::deque<uint64_t> privateDirty_ = {}; 1788 std::deque<uint64_t> swap_ = {}; 1789 std::deque<uint64_t> swapPss_ = {}; 1790 std::deque<uint32_t> type_ = {}; 1791 uint32_t rowCount_ = 0; 1792 }; 1793 class BioLatencySampleData : public CacheBase { 1794 public: 1795 void AppendNewData(uint32_t callChainId, 1796 uint64_t type, 1797 uint32_t ipid, 1798 uint32_t itid, 1799 uint64_t startTs, 1800 uint64_t endTs, 1801 uint64_t latencyDur, 1802 uint32_t tier, 1803 uint64_t size, 1804 uint64_t blockNumber, 1805 uint64_t filePathId, 1806 uint64_t durPer4k); 1807 const std::deque<uint64_t>& Id() const; 1808 const std::deque<uint32_t>& CallChainIds() const; 1809 const std::deque<uint64_t>& Types() const; 1810 const std::deque<uint32_t>& Ipids() const; 1811 const std::deque<uint32_t>& Itids() const; 1812 const std::deque<uint64_t>& StartTs() const; 1813 const std::deque<uint64_t>& EndTs() const; 1814 const std::deque<uint64_t>& LatencyDurs() const; 1815 const std::deque<uint32_t>& Tiers() const; 1816 const std::deque<uint64_t>& Sizes() const; 1817 const std::deque<uint64_t>& BlockNumbers() const; 1818 const std::deque<uint64_t>& FilePathIds() const; 1819 const std::deque<uint64_t>& DurPer4k() const; Clear()1820 void Clear() override 1821 { 1822 CacheBase::Clear(); 1823 callChainIds_.clear(); 1824 types_.clear(); 1825 ipids_.clear(); 1826 itids_.clear(); 1827 startTs_.clear(); 1828 endTs_.clear(); 1829 latencyDurs_.clear(); 1830 tiers_.clear(); 1831 sizes_.clear(); 1832 blockNumbers_.clear(); 1833 filePathIds_.clear(); 1834 durPer4ks_.clear(); 1835 } 1836 1837 private: 1838 std::deque<uint32_t> callChainIds_ = {}; 1839 std::deque<uint64_t> types_ = {}; 1840 std::deque<uint32_t> ipids_ = {}; 1841 std::deque<uint32_t> itids_ = {}; 1842 std::deque<uint64_t> startTs_ = {}; 1843 std::deque<uint64_t> endTs_ = {}; 1844 std::deque<uint64_t> latencyDurs_ = {}; 1845 std::deque<uint32_t> tiers_ = {}; 1846 std::deque<uint64_t> sizes_ = {}; 1847 std::deque<uint64_t> blockNumbers_ = {}; 1848 std::deque<uint64_t> filePathIds_ = {}; 1849 std::deque<uint64_t> durPer4ks_ = {}; 1850 uint32_t rowCount_ = 0; 1851 }; 1852 class ClockSnapshotData { 1853 public: AppendNewSnapshot(uint8_t clockId,uint64_t ts,const std::string & name)1854 size_t AppendNewSnapshot(uint8_t clockId, uint64_t ts, const std::string& name) 1855 { 1856 clockIds_.emplace_back(clockId); 1857 ts_.emplace_back(ts); 1858 names_.emplace_back(name); 1859 return ts_.size(); 1860 } Size()1861 size_t Size() const 1862 { 1863 return ts_.size(); 1864 } ClockIds()1865 const std::deque<uint8_t>& ClockIds() const 1866 { 1867 return clockIds_; 1868 } Ts()1869 const std::deque<uint64_t>& Ts() const 1870 { 1871 return ts_; 1872 } Names()1873 const std::deque<std::string>& Names() const 1874 { 1875 return names_; 1876 } 1877 1878 private: 1879 std::deque<uint8_t> clockIds_ = {}; 1880 std::deque<uint64_t> ts_ = {}; 1881 std::deque<std::string> names_ = {}; 1882 }; 1883 class DataSourceClockIdData { 1884 public: 1885 DataSourceClockIdData(); AppendNewDataSourceClockId(const std::string & dataSoruceName,uint8_t clockId)1886 size_t AppendNewDataSourceClockId(const std::string& dataSoruceName, uint8_t clockId) 1887 { 1888 dataSourceNames_.emplace_back(dataSoruceName); 1889 clockIds_.emplace_back(clockId); 1890 return dataSourceNames_.size(); 1891 } Size()1892 size_t Size() const 1893 { 1894 return dataSourceNames_.size(); 1895 } ClockIds()1896 const std::deque<uint8_t>& ClockIds() const 1897 { 1898 return clockIds_; 1899 } Names()1900 const std::deque<std::string>& Names() const 1901 { 1902 return dataSourceNames_; 1903 } 1904 void SetDataSourceClockId(DataSourceType source, uint32_t id); 1905 void Finish(); 1906 1907 private: 1908 std::deque<std::string> dataSourceNames_ = {}; 1909 std::deque<uint8_t> clockIds_ = {}; 1910 std::map<DataSourceType, uint8_t> dataSource2ClockIdMap_ = {}; 1911 std::map<DataSourceType, std::string> dataSource2PluginNameMap_ = {}; 1912 }; 1913 1914 class FrameSlice : public CacheBase { 1915 public: 1916 size_t AppendFrame(uint64_t ts, uint32_t ipid, uint32_t itid, uint32_t vsyncId, uint64_t callStackSliceId); 1917 size_t AppendFrame(uint64_t ts, 1918 uint32_t ipid, 1919 uint32_t itid, 1920 uint32_t vsyncId, 1921 uint64_t callStackSliceId, 1922 uint64_t end, 1923 uint8_t type); 1924 void SetEndTime(uint64_t row, uint64_t end); 1925 void SetType(uint64_t row, uint8_t type); 1926 void SetDst(uint64_t row, uint64_t dst); 1927 void SetSrcs(uint64_t row, const std::vector<uint64_t>& fromSlices); 1928 void SetFlags(uint64_t row, const uint32_t flags); 1929 const std::deque<uint32_t> Ipids() const; 1930 const std::deque<uint32_t> VsyncIds() const; 1931 const std::deque<uint64_t> CallStackIds() const; 1932 const std::deque<uint64_t> EndTss() const; 1933 const std::deque<uint64_t> Dsts() const; 1934 const std::deque<uint64_t> Durs() const; 1935 const std::deque<uint8_t> Types() const; 1936 const std::deque<uint8_t> Flags() const; 1937 const std::deque<uint8_t> Depths() const; 1938 const std::deque<uint32_t> FrameNos() const; 1939 const std::deque<std::string>& Srcs() const; 1940 void UpdateCallStackSliceId(uint64_t row, uint64_t callStackSliceId); 1941 void SetEndTimeAndFlag(uint64_t row, uint64_t ts, uint64_t expectDur, uint64_t expectEnd); 1942 void Erase(uint64_t row); GetAbnormalStartEndTimeState()1943 static const uint32_t GetAbnormalStartEndTimeState() 1944 { 1945 return abnormalStartEndTimeState_; 1946 } 1947 1948 public: 1949 typedef enum FrameSliceType { ACTURAL_SLICE, EXPECT_SLICE } FrameSliceType; 1950 1951 private: 1952 std::deque<uint32_t> ipids_ = {}; 1953 std::deque<uint64_t> dsts_ = {}; 1954 std::deque<std::string> srcs_ = {}; 1955 std::deque<uint32_t> vsyncIds_ = {}; 1956 std::deque<uint64_t> callStackIds_ = {}; 1957 std::deque<uint64_t> endTss_ = {}; 1958 std::deque<uint64_t> durs_ = {}; 1959 std::deque<uint8_t> types_ = {}; 1960 std::deque<uint8_t> flags_ = {}; 1961 std::deque<uint8_t> depths_ = {}; 1962 std::deque<uint32_t> frameNos_ = {}; 1963 const uint32_t INVALID_ROW = 2; 1964 static const uint32_t abnormalStartEndTimeState_ = 3; 1965 }; 1966 class FrameMaps : public CacheBase { 1967 public: 1968 size_t AppendNew(FrameSlice* frameSlice, uint64_t src, uint64_t dst); 1969 const std::deque<uint64_t>& SrcIndexs() const; 1970 const std::deque<uint64_t>& DstIndexs() const; 1971 1972 private: 1973 std::deque<uint64_t> srcs_ = {}; 1974 std::deque<uint64_t> dsts_ = {}; 1975 }; 1976 1977 class AppStartup : public CacheBase { 1978 public: 1979 size_t AppendNewData(uint32_t ipid, 1980 uint32_t tid, 1981 uint32_t callId, 1982 uint64_t startTime, 1983 uint64_t endTime, 1984 uint32_t startName, 1985 DataIndex packedName); 1986 const std::deque<uint32_t>& Pids() const; 1987 const std::deque<uint32_t>& Tids() const; 1988 const std::deque<uint32_t>& CallIds() const; 1989 const std::deque<uint64_t>& StartTimes() const; 1990 const std::deque<uint64_t>& EndTimes() const; 1991 const std::deque<uint32_t>& StartNames() const; 1992 const std::deque<DataIndex>& PackedNames() const; 1993 Clear()1994 void Clear() override 1995 { 1996 CacheBase::Clear(); 1997 ipids_.clear(); 1998 tids_.clear(); 1999 callIds_.clear(); 2000 startTimes_.clear(); 2001 endTimes_.clear(); 2002 startNames_.clear(); 2003 packedNames_.clear(); 2004 } 2005 2006 private: 2007 std::deque<uint32_t> ipids_ = {}; 2008 std::deque<uint32_t> tids_ = {}; 2009 std::deque<uint32_t> callIds_ = {}; 2010 std::deque<uint64_t> startTimes_ = {}; 2011 std::deque<uint64_t> endTimes_ = {}; 2012 std::deque<uint32_t> startNames_ = {}; 2013 std::deque<DataIndex> packedNames_ = {}; 2014 }; 2015 2016 class SoStaticInitalization : public CacheBase { 2017 public: 2018 size_t AppendNewData(uint32_t ipid, 2019 uint32_t tid, 2020 uint32_t callId, 2021 uint64_t startTime, 2022 uint64_t endTime, 2023 DataIndex soName, 2024 uint32_t depth); 2025 const std::deque<uint32_t>& Pids() const; 2026 const std::deque<uint32_t>& Tids() const; 2027 const std::deque<uint32_t>& CallIds() const; 2028 const std::deque<uint64_t>& StartTimes() const; 2029 const std::deque<uint64_t>& EndTimes() const; 2030 const std::deque<DataIndex>& SoNames() const; 2031 const std::deque<uint32_t> Depths() const; 2032 Clear()2033 void Clear() override 2034 { 2035 CacheBase::Clear(); 2036 ipids_.clear(); 2037 tids_.clear(); 2038 callIds_.clear(); 2039 startTimes_.clear(); 2040 endTimes_.clear(); 2041 soNames_.clear(); 2042 depths_.clear(); 2043 } 2044 2045 private: 2046 std::deque<uint32_t> ipids_ = {}; 2047 std::deque<uint32_t> tids_ = {}; 2048 std::deque<uint32_t> callIds_ = {}; 2049 std::deque<uint64_t> startTimes_ = {}; 2050 std::deque<uint64_t> endTimes_ = {}; 2051 std::deque<DataIndex> soNames_ = {}; 2052 std::deque<uint32_t> depths_ = {}; 2053 }; 2054 2055 class JsHeapFiles : public CacheBase { 2056 public: 2057 size_t 2058 AppendNewData(uint32_t id, std::string filePath, uint64_t startTime, uint64_t endTime, uint64_t selfSizeCount); 2059 const std::deque<uint32_t>& IDs() const; 2060 const std::deque<std::string>& FilePaths() const; 2061 const std::deque<uint64_t>& StartTimes() const; 2062 const std::deque<uint64_t>& EndTimes() const; 2063 const std::deque<uint64_t>& SelfSizeCount() const; Clear()2064 void Clear() override 2065 { 2066 CacheBase::Clear(); 2067 fileIds_.clear(); 2068 filePaths_.clear(); 2069 startTimes_.clear(); 2070 endTimes_.clear(); 2071 selfSizeCount_.clear(); 2072 } 2073 2074 private: 2075 std::deque<uint32_t> fileIds_ = {}; 2076 std::deque<std::string> filePaths_ = {}; 2077 std::deque<uint64_t> startTimes_ = {}; 2078 std::deque<uint64_t> endTimes_ = {}; 2079 std::deque<uint64_t> selfSizeCount_ = {}; 2080 }; 2081 2082 class JsHeapEdges : public CacheBase { 2083 public: 2084 size_t AppendNewData(uint32_t fileId, 2085 uint32_t edgeIndex, 2086 uint32_t type, 2087 uint32_t nameOrIndex, 2088 uint32_t toNode, 2089 uint32_t fromNodeId, 2090 uint32_t toNodeId); 2091 const std::deque<uint32_t>& FileIds() const; 2092 const std::deque<uint32_t>& EdgeIndexs() const; 2093 const std::deque<uint32_t>& Types() const; 2094 const std::deque<uint32_t>& NameOrIndexs() const; 2095 const std::deque<uint32_t>& ToNodes() const; 2096 const std::deque<uint32_t>& FromNodeIds() const; 2097 const std::deque<uint32_t>& ToNodeIds() const; Clear()2098 void Clear() override 2099 { 2100 CacheBase::Clear(); 2101 fileIds_.clear(); 2102 edgeIndexs_.clear(); 2103 types_.clear(); 2104 nameOrIndexs_.clear(); 2105 toNodes_.clear(); 2106 fromNodeIds_.clear(); 2107 toNodeIds_.clear(); 2108 } 2109 2110 private: 2111 std::deque<uint32_t> fileIds_ = {}; 2112 std::deque<uint32_t> edgeIndexs_ = {}; 2113 std::deque<uint32_t> types_ = {}; 2114 std::deque<uint32_t> nameOrIndexs_ = {}; 2115 std::deque<uint32_t> toNodes_ = {}; 2116 std::deque<uint32_t> fromNodeIds_ = {}; 2117 std::deque<uint32_t> toNodeIds_ = {}; 2118 }; 2119 2120 class JsHeapInfo : public CacheBase { 2121 public: 2122 size_t AppendNewData(uint32_t fileId, std::string key, uint32_t type, int32_t intValue, std::string strValue); 2123 const std::deque<uint32_t>& FileIds() const; 2124 const std::deque<std::string>& Keys() const; 2125 const std::deque<uint32_t>& Types() const; 2126 const std::deque<int32_t>& IntValues() const; 2127 const std::deque<std::string>& StrValues() const; Clear()2128 void Clear() override 2129 { 2130 CacheBase::Clear(); 2131 fileIds_.clear(); 2132 keys_.clear(); 2133 types_.clear(); 2134 intValues_.clear(); 2135 strValues_.clear(); 2136 } 2137 2138 private: 2139 std::deque<uint32_t> fileIds_ = {}; 2140 std::deque<std::string> keys_ = {}; 2141 std::deque<uint32_t> types_ = {}; 2142 std::deque<int32_t> intValues_ = {}; 2143 std::deque<std::string> strValues_ = {}; 2144 }; 2145 2146 class JsHeapLocation : public CacheBase { 2147 public: 2148 size_t AppendNewData(uint32_t fileId, uint32_t objectIndex, uint32_t scriptId, uint32_t line, uint32_t column); 2149 const std::deque<uint32_t>& FileIds() const; 2150 const std::deque<uint32_t>& ObjectIndexs() const; 2151 const std::deque<uint32_t>& ScriptIds() const; 2152 const std::deque<uint32_t>& Lines() const; 2153 const std::deque<uint32_t>& Columns() const; Clear()2154 void Clear() override 2155 { 2156 CacheBase::Clear(); 2157 fileIds_.clear(); 2158 objectIndexs_.clear(); 2159 scriptIds_.clear(); 2160 lines_.clear(); 2161 columns_.clear(); 2162 } 2163 2164 private: 2165 std::deque<uint32_t> fileIds_ = {}; 2166 std::deque<uint32_t> objectIndexs_ = {}; 2167 std::deque<uint32_t> scriptIds_ = {}; 2168 std::deque<uint32_t> lines_ = {}; 2169 std::deque<uint32_t> columns_ = {}; 2170 }; 2171 2172 class JsHeapNodes : public CacheBase { 2173 public: 2174 size_t AppendNewData(uint32_t fileId, 2175 uint32_t nodeIndex, 2176 uint32_t type, 2177 uint32_t name, 2178 uint32_t id, 2179 uint32_t selfSize, 2180 uint32_t edgeCount, 2181 uint32_t traceNodeId, 2182 uint32_t detachedNess); 2183 const std::deque<uint32_t>& FileIds() const; 2184 const std::deque<uint32_t>& NodeIndexs() const; 2185 const std::deque<uint32_t>& Types() const; 2186 const std::deque<uint32_t>& Names() const; 2187 const std::deque<uint32_t>& NodeIds() const; 2188 const std::deque<uint32_t>& SelfSizes() const; 2189 const std::deque<uint32_t>& EdgeCounts() const; 2190 const std::deque<uint32_t>& TraceNodeIds() const; 2191 const std::deque<uint32_t>& DetachedNess() const; Clear()2192 void Clear() override 2193 { 2194 CacheBase::Clear(); 2195 fileIds_.clear(); 2196 nodeIndexs_.clear(); 2197 types_.clear(); 2198 names_.clear(); 2199 nodeIds_.clear(); 2200 selfSizes_.clear(); 2201 edgeCounts_.clear(); 2202 traceNodeIds_.clear(); 2203 detachedNess_.clear(); 2204 } 2205 2206 private: 2207 std::deque<uint32_t> fileIds_ = {}; 2208 std::deque<uint32_t> nodeIndexs_ = {}; 2209 std::deque<uint32_t> types_ = {}; 2210 std::deque<uint32_t> names_ = {}; 2211 std::deque<uint32_t> nodeIds_ = {}; 2212 std::deque<uint32_t> selfSizes_ = {}; 2213 std::deque<uint32_t> edgeCounts_ = {}; 2214 std::deque<uint32_t> traceNodeIds_ = {}; 2215 std::deque<uint32_t> detachedNess_ = {}; 2216 }; 2217 2218 class JsHeapSample : public CacheBase { 2219 public: 2220 size_t AppendNewData(uint32_t fileId, uint64_t timeStampUs, uint32_t lastAssignedId); 2221 const std::deque<uint32_t>& FileIds() const; 2222 const std::deque<uint64_t>& TimeStampUs() const; 2223 const std::deque<uint32_t>& LastAssignedIds() const; Clear()2224 void Clear() override 2225 { 2226 CacheBase::Clear(); 2227 fileIds_.clear(); 2228 timeStampUs_.clear(); 2229 lastAssignedIds_.clear(); 2230 } 2231 2232 private: 2233 std::deque<uint32_t> fileIds_ = {}; 2234 std::deque<uint64_t> timeStampUs_ = {}; 2235 std::deque<uint32_t> lastAssignedIds_ = {}; 2236 }; 2237 2238 class JsHeapString : public CacheBase { 2239 public: 2240 size_t AppendNewData(uint32_t fileId, uint32_t fileIndex, std::string string); 2241 const std::deque<uint32_t>& FileIds() const; 2242 const std::deque<uint64_t>& FileIndexs() const; 2243 const std::deque<std::string>& Strings() const; Clear()2244 void Clear() override 2245 { 2246 CacheBase::Clear(); 2247 fileIds_.clear(); 2248 fileIndexs_.clear(); 2249 strings_.clear(); 2250 } 2251 2252 private: 2253 std::deque<uint32_t> fileIds_ = {}; 2254 std::deque<uint64_t> fileIndexs_ = {}; 2255 std::deque<std::string> strings_ = {}; 2256 }; 2257 2258 class JsHeapTraceFuncInfo : public CacheBase { 2259 public: 2260 size_t AppendNewData(uint32_t fileId, 2261 uint32_t functionIndex, 2262 uint32_t functionId, 2263 uint32_t name, 2264 uint32_t scriptName, 2265 uint32_t scriptId, 2266 uint32_t line, 2267 uint32_t column); 2268 const std::deque<uint32_t>& FileIds() const; 2269 const std::deque<uint32_t>& FunctionIndexs() const; 2270 const std::deque<uint32_t>& FunctionIds() const; 2271 const std::deque<uint32_t>& Names() const; 2272 const std::deque<uint32_t>& ScriptNames() const; 2273 const std::deque<uint32_t>& ScriptIds() const; 2274 const std::deque<uint32_t>& Lines() const; 2275 const std::deque<uint32_t>& Columns() const; Clear()2276 void Clear() override 2277 { 2278 CacheBase::Clear(); 2279 fileIds_.clear(); 2280 functionIndexs_.clear(); 2281 functionIds_.clear(); 2282 names_.clear(); 2283 scriptNames_.clear(); 2284 scriptIds_.clear(); 2285 lines_.clear(); 2286 columns_.clear(); 2287 } 2288 2289 private: 2290 std::deque<uint32_t> fileIds_ = {}; 2291 std::deque<uint32_t> functionIndexs_ = {}; 2292 std::deque<uint32_t> functionIds_ = {}; 2293 std::deque<uint32_t> names_ = {}; 2294 std::deque<uint32_t> scriptNames_ = {}; 2295 std::deque<uint32_t> scriptIds_ = {}; 2296 std::deque<uint32_t> lines_ = {}; 2297 std::deque<uint32_t> columns_ = {}; 2298 }; 2299 2300 class JsHeapTraceNode : public CacheBase { 2301 public: 2302 size_t AppendNewData(uint32_t fileId, 2303 uint32_t traceNodeId, 2304 uint32_t functionInfoIndex, 2305 uint32_t count, 2306 uint32_t size, 2307 int32_t parentId); 2308 const std::deque<uint32_t>& FileIds() const; 2309 const std::deque<uint32_t>& TraceNodeIDs() const; 2310 const std::deque<uint32_t>& FunctionInfoIndexs() const; 2311 const std::deque<uint32_t>& Counts() const; 2312 const std::deque<uint32_t>& NodeSizes() const; 2313 const std::deque<int32_t>& ParentIds() const; Clear()2314 void Clear() override 2315 { 2316 CacheBase::Clear(); 2317 fileIds_.clear(); 2318 traceNodeIds_.clear(); 2319 functionInfoIndexs_.clear(); 2320 counts_.clear(); 2321 sizes_.clear(); 2322 parentIds_.clear(); 2323 } 2324 2325 private: 2326 std::deque<uint32_t> fileIds_ = {}; 2327 std::deque<uint32_t> traceNodeIds_ = {}; 2328 std::deque<uint32_t> functionInfoIndexs_ = {}; 2329 std::deque<uint32_t> counts_ = {}; 2330 std::deque<uint32_t> sizes_ = {}; 2331 std::deque<int32_t> parentIds_ = {}; 2332 }; 2333 2334 class JsConfig : public CacheBase { 2335 public: 2336 size_t AppendNewData(uint32_t pid, 2337 uint64_t type, 2338 uint32_t interval, 2339 uint32_t captureNumericValue, 2340 uint32_t trackAllocation, 2341 uint32_t cpuProfiler, 2342 uint32_t cpuProfilerInterval); 2343 const std::deque<uint32_t>& Pids() const; 2344 const std::deque<uint64_t>& Types() const; 2345 const std::deque<uint32_t>& Intervals() const; 2346 const std::deque<uint32_t>& CaptureNumericValue() const; 2347 const std::deque<uint32_t>& TrackAllocations() const; 2348 const std::deque<uint32_t>& CpuProfiler() const; 2349 const std::deque<uint32_t>& CpuProfilerInterval() const; Clear()2350 void Clear() override 2351 { 2352 CacheBase::Clear(); 2353 pids_.clear(); 2354 types_.clear(); 2355 intervals_.clear(); 2356 captureNumericValues_.clear(); 2357 trackAllocations_.clear(); 2358 cpuProfilers_.clear(); 2359 cpuProfilerIntervals_.clear(); 2360 } 2361 2362 private: 2363 std::deque<uint32_t> pids_ = {}; 2364 std::deque<uint64_t> types_ = {}; 2365 std::deque<uint32_t> intervals_ = {}; 2366 std::deque<uint32_t> captureNumericValues_ = {}; 2367 std::deque<uint32_t> trackAllocations_ = {}; 2368 std::deque<uint32_t> cpuProfilers_ = {}; 2369 std::deque<uint32_t> cpuProfilerIntervals_ = {}; 2370 }; 2371 2372 class JsCpuProfilerNode : public CacheBase { 2373 public: 2374 size_t AppendNewData(uint32_t functionId, 2375 uint32_t functionName, 2376 std::string scriptId, 2377 uint32_t url, 2378 uint32_t lineNumber, 2379 uint32_t columnNumber, 2380 uint32_t hitCount, 2381 std::string children, 2382 uint32_t parent); 2383 const std::deque<uint32_t>& FunctionIds() const; 2384 const std::deque<uint32_t>& FunctionNames() const; 2385 const std::deque<std::string>& ScriptIds() const; 2386 const std::deque<uint32_t>& Urls() const; 2387 const std::deque<uint32_t>& LineNumbers() const; 2388 const std::deque<int32_t>& ColumnNumbers() const; 2389 const std::deque<int32_t>& HitCounts() const; 2390 const std::deque<std::string>& Children() const; 2391 const std::deque<uint32_t>& Parents() const; Clear()2392 void Clear() override 2393 { 2394 CacheBase::Clear(); 2395 functionIds_.clear(); 2396 functionNames_.clear(); 2397 scriptIds_.clear(); 2398 urls_.clear(); 2399 lineNumbers_.clear(); 2400 columnNumbers_.clear(); 2401 hitCounts_.clear(); 2402 children_.clear(); 2403 parents_.clear(); 2404 } 2405 2406 private: 2407 std::deque<uint32_t> functionIds_ = {}; 2408 std::deque<uint32_t> functionNames_ = {}; 2409 std::deque<std::string> scriptIds_ = {}; 2410 std::deque<uint32_t> urls_ = {}; 2411 std::deque<uint32_t> lineNumbers_ = {}; 2412 std::deque<int32_t> columnNumbers_ = {}; 2413 std::deque<int32_t> hitCounts_ = {}; 2414 std::deque<std::string> children_ = {}; 2415 std::deque<uint32_t> parents_ = {}; 2416 }; 2417 2418 class JsCpuProfilerSample : public CacheBase { 2419 public: 2420 size_t AppendNewData(uint32_t functionId, uint64_t startTime, uint64_t endTime, uint64_t dur); 2421 const std::deque<uint32_t>& FunctionIds() const; 2422 const std::deque<uint64_t>& StartTimes() const; 2423 const std::deque<uint64_t>& EndTimes() const; 2424 const std::deque<uint64_t>& Durs() const; Clear()2425 void Clear() override 2426 { 2427 CacheBase::Clear(); 2428 functionIds_.clear(); 2429 startTimes_.clear(); 2430 endTimes_.clear(); 2431 durs_.clear(); 2432 } 2433 2434 private: 2435 std::deque<uint32_t> functionIds_ = {}; 2436 std::deque<uint64_t> startTimes_ = {}; 2437 std::deque<uint64_t> endTimes_ = {}; 2438 std::deque<uint64_t> durs_ = {}; 2439 }; 2440 2441 class GPUSlice { 2442 public: 2443 size_t AppendNew(uint32_t frameRow, uint64_t dur); 2444 const std::deque<uint32_t>& FrameRows() const; 2445 const std::deque<uint64_t>& Durs() const; 2446 size_t Size() const; 2447 2448 private: 2449 std::deque<uint32_t> frameRows_ = {}; 2450 std::deque<uint64_t> durs_ = {}; 2451 }; 2452 2453 class TaskPoolInfo : public CacheBase { 2454 public: 2455 size_t AppendAllocationTaskData(uint32_t allocationTaskRow, 2456 uint32_t allocationItid, 2457 uint32_t executeId, 2458 uint32_t priority, 2459 uint32_t executeState); 2460 size_t AppendExecuteTaskData(uint32_t executeTaskRow, uint32_t executeItid, uint32_t executeId); 2461 size_t AppendReturnTaskData(uint32_t returnTaskRow, uint32_t returnItid, uint32_t executeId, uint32_t returnState); 2462 void UpdateAllocationTaskData(uint32_t index, 2463 uint32_t allocationTaskRow, 2464 uint32_t allocationItid, 2465 uint32_t priority, 2466 uint32_t executeState); 2467 void UpdateExecuteTaskData(uint32_t index, uint32_t executeTaskRow, uint32_t executeItid); 2468 void UpdateReturnTaskData(uint32_t index, uint32_t returnTaskRow, uint32_t returnItid, uint32_t returnState); 2469 void AppendTimeoutRow(uint32_t index, uint32_t timeoutRow); 2470 2471 const std::deque<uint32_t>& AllocationTaskRows() const; 2472 const std::deque<uint32_t>& ExecuteTaskRows() const; 2473 const std::deque<uint32_t>& ReturnTaskRows() const; 2474 const std::deque<uint32_t>& AllocationItids() const; 2475 const std::deque<uint32_t>& ExecuteItids() const; 2476 const std::deque<uint32_t>& ReturnItids() const; 2477 const std::deque<uint32_t>& ExecuteIds() const; 2478 const std::deque<uint32_t>& Prioritys() const; 2479 const std::deque<uint32_t>& ExecuteStates() const; 2480 const std::deque<uint32_t>& ReturnStates() const; 2481 const std::deque<uint32_t>& TimeoutRows() const; Clear()2482 void Clear() override 2483 { 2484 CacheBase::Clear(); 2485 allocationTaskRows_.clear(); 2486 executeTaskRows_.clear(); 2487 returnTaskRows_.clear(); 2488 allocationItids_.clear(); 2489 executeItids_.clear(); 2490 returnItids_.clear(); 2491 executeIds_.clear(); 2492 prioritys_.clear(); 2493 executeStates_.clear(); 2494 returnStates_.clear(); 2495 timeoutRows_.clear(); 2496 } 2497 2498 private: 2499 std::deque<uint32_t> allocationTaskRows_ = {}; 2500 std::deque<uint32_t> executeTaskRows_ = {}; 2501 std::deque<uint32_t> returnTaskRows_ = {}; 2502 std::deque<uint32_t> allocationItids_ = {}; 2503 std::deque<uint32_t> executeItids_ = {}; 2504 std::deque<uint32_t> returnItids_ = {}; 2505 std::deque<uint32_t> executeIds_ = {}; 2506 std::deque<uint32_t> prioritys_ = {}; 2507 std::deque<uint32_t> executeStates_ = {}; 2508 std::deque<uint32_t> returnStates_ = {}; 2509 std::deque<uint32_t> timeoutRows_ = {}; 2510 }; 2511 class Animation { 2512 public: 2513 TableRowId AppendAnimation(InternalTime startPoint); 2514 void UpdateStartPoint(TableRowId index, InternalTime startPoint); 2515 void UpdateEndPoint(TableRowId index, InternalTime endPoint); 2516 size_t Size() const; 2517 const std::deque<InternalTime>& InputTimes() const; 2518 const std::deque<InternalTime>& StartPoints() const; 2519 const std::deque<InternalTime>& EndPoints() const; 2520 const std::deque<uint64_t>& IdsData() const; 2521 void Clear(); 2522 2523 private: 2524 std::deque<InternalTime> inputTimes_ = {}; 2525 std::deque<InternalTime> startPoints_ = {}; 2526 std::deque<InternalTime> endPoins_ = {}; 2527 std::deque<uint64_t> ids_ = {}; 2528 }; 2529 class DeviceInfo { 2530 public: 2531 uint32_t PhysicalWidth() const; 2532 uint32_t PhysicalHeight() const; 2533 uint32_t PhysicalFrameRate() const; 2534 void UpdateWidthAndHeight(const std::smatch& matcheLine); 2535 void UpdateFrameRate(uint32_t frameRate); 2536 2537 void Clear(); 2538 2539 private: 2540 uint32_t physicalWidth_ = INVALID_UINT32; 2541 uint32_t physicalHeight_ = INVALID_UINT32; 2542 uint32_t physicalFrameRate_ = INVALID_UINT32; 2543 }; 2544 class DynamicFrame { 2545 public: 2546 TableRowId AppendDynamicFrame(DataIndex nameId); 2547 void UpdateNameIndex(TableRowId index, DataIndex nameId); 2548 void UpdatePosition(TableRowId index, const std::smatch& matcheLine, DataIndex alpha); 2549 void UpdateEndTime(TableRowId index, InternalTime endTime); 2550 2551 size_t Size() const; 2552 const std::deque<uint64_t>& IdsData() const; 2553 const std::deque<uint32_t>& Xs() const; 2554 const std::deque<uint32_t>& Ys() const; 2555 const std::deque<uint32_t>& Widths() const; 2556 const std::deque<uint32_t>& Heights() const; 2557 const std::deque<DataIndex>& Alphas() const; 2558 const std::deque<DataIndex>& Names() const; 2559 const std::deque<InternalTime>& EndTimes() const; 2560 void Clear(); 2561 2562 private: 2563 std::deque<uint32_t> xs_ = {}; 2564 std::deque<uint32_t> ys_ = {}; 2565 std::deque<uint32_t> widths_ = {}; 2566 std::deque<uint32_t> heights_ = {}; 2567 std::deque<DataIndex> alphas_ = {}; 2568 std::deque<DataIndex> names_ = {}; 2569 std::deque<InternalTime> endTimes_ = {}; 2570 std::deque<uint64_t> ids_ = {}; 2571 }; 2572 2573 class AshMemData : public CacheBase { 2574 public: 2575 void AppendNewData(InternalPid ipid, 2576 uint64_t ts, 2577 uint32_t adj, 2578 uint32_t fd, 2579 DataIndex ashmemNameId, 2580 uint64_t size, 2581 uint64_t pss, 2582 uint32_t ashmemId, 2583 uint64_t time, 2584 uint64_t refCount, 2585 uint64_t purged, 2586 uint32_t flag); 2587 const std::deque<InternalPid>& Ipids() const; 2588 const std::deque<uint32_t>& Adjs() const; 2589 const std::deque<uint32_t>& Fds() const; 2590 const std::deque<DataIndex>& AshmemNameIds() const; 2591 const std::deque<uint64_t>& Sizes() const; 2592 const std::deque<uint64_t>& Psss() const; 2593 const std::deque<uint32_t>& AshmemIds() const; 2594 const std::deque<uint64_t>& Times() const; 2595 const std::deque<uint64_t>& RefCounts() const; 2596 const std::deque<uint64_t>& Purgeds() const; 2597 const std::deque<uint32_t>& Flags() const; Clear()2598 void Clear() override 2599 { 2600 CacheBase::Clear(); 2601 ipids_.clear(); 2602 adjs_.clear(); 2603 fds_.clear(); 2604 ashmemNameIds_.clear(); 2605 sizes_.clear(); 2606 psss_.clear(); 2607 ashmemIds_.clear(); 2608 times_.clear(); 2609 refCounts_.clear(); 2610 purgeds_.clear(); 2611 flags_.clear(); 2612 } 2613 void SetFlag(uint64_t rowId, uint32_t Flag); 2614 2615 private: 2616 std::deque<InternalPid> ipids_ = {}; 2617 std::deque<uint32_t> adjs_ = {}; 2618 std::deque<uint32_t> fds_ = {}; 2619 std::deque<DataIndex> ashmemNameIds_ = {}; 2620 std::deque<uint64_t> sizes_ = {}; 2621 std::deque<uint64_t> psss_ = {}; 2622 std::deque<uint32_t> ashmemIds_ = {}; 2623 std::deque<uint64_t> times_ = {}; 2624 std::deque<uint64_t> refCounts_ = {}; 2625 std::deque<uint64_t> purgeds_ = {}; 2626 std::deque<uint32_t> flags_ = {}; 2627 uint32_t rowCount_ = 0; 2628 }; 2629 2630 class DmaMemData : public CacheBase { 2631 public: 2632 void AppendNewData(InternalPid ipid, 2633 uint64_t ts, 2634 uint32_t fd, 2635 uint64_t size, 2636 uint32_t ino, 2637 uint32_t expPid, 2638 DataIndex expTaskCommId, 2639 DataIndex bufNameId, 2640 DataIndex expNameId, 2641 uint32_t flag); 2642 const std::deque<InternalPid>& Ipids() const; 2643 const std::deque<uint32_t>& Fds() const; 2644 const std::deque<uint64_t>& Sizes() const; 2645 const std::deque<uint32_t>& Inos() const; 2646 const std::deque<uint32_t>& ExpPids() const; 2647 const std::deque<DataIndex>& ExpTaskCommIds() const; 2648 const std::deque<DataIndex>& BufNameIds() const; 2649 const std::deque<DataIndex>& ExpNameIds() const; 2650 const std::deque<uint32_t>& Flags() const; Clear()2651 void Clear() override 2652 { 2653 CacheBase::Clear(); 2654 ipids_.clear(); 2655 fds_.clear(); 2656 sizes_.clear(); 2657 inos_.clear(); 2658 expPids_.clear(); 2659 expTaskCommIds_.clear(); 2660 bufNameIds_.clear(); 2661 expNameIds_.clear(); 2662 flags_.clear(); 2663 } 2664 void SetFlag(uint64_t rowId, uint32_t Flag); 2665 2666 private: 2667 std::deque<InternalPid> ipids_ = {}; 2668 std::deque<uint32_t> fds_ = {}; 2669 std::deque<uint64_t> sizes_ = {}; 2670 std::deque<uint32_t> inos_ = {}; 2671 std::deque<uint32_t> expPids_ = {}; 2672 std::deque<DataIndex> expTaskCommIds_ = {}; 2673 std::deque<DataIndex> bufNameIds_ = {}; 2674 std::deque<DataIndex> expNameIds_ = {}; 2675 std::deque<uint32_t> flags_ = {}; 2676 uint32_t rowCount_ = 0; 2677 }; 2678 2679 class GpuProcessMemData : public CacheBase { 2680 public: 2681 void AppendNewData(uint64_t ts, 2682 DataIndex gpuNameId, 2683 uint64_t allGpuSize, 2684 std::string addr, 2685 InternalPid ipid, 2686 InternalPid itid, 2687 uint64_t usedGpuSize); 2688 const std::deque<DataIndex>& GpuNameIds() const; 2689 const std::deque<uint64_t>& AllGpuSizes() const; 2690 const std::deque<std::string>& Addrs() const; 2691 const std::deque<InternalPid>& Ipids() const; 2692 const std::deque<InternalPid>& Itids() const; 2693 const std::deque<uint64_t>& UsedGpuSizes() const; Clear()2694 void Clear() override 2695 { 2696 CacheBase::Clear(); 2697 gpuNameIds_.clear(); 2698 allGpuSizes_.clear(); 2699 addrs_.clear(); 2700 ipids_.clear(); 2701 itids_.clear(); 2702 usedGpuSizes_.clear(); 2703 } 2704 2705 private: 2706 std::deque<DataIndex> gpuNameIds_ = {}; 2707 std::deque<uint64_t> allGpuSizes_ = {}; 2708 std::deque<std::string> addrs_ = {}; 2709 std::deque<InternalPid> ipids_ = {}; 2710 std::deque<InternalPid> itids_ = {}; 2711 std::deque<uint64_t> usedGpuSizes_ = {}; 2712 uint32_t rowCount_ = 0; 2713 }; 2714 2715 class GpuWindowMemData : public CacheBase { 2716 public: 2717 void AppendNewData(uint64_t ts, 2718 DataIndex windowNameId, 2719 uint64_t windowId, 2720 DataIndex moduleNameId, 2721 DataIndex categoryNameId, 2722 uint64_t size, 2723 uint32_t count, 2724 uint64_t purgeableSize); 2725 const std::deque<DataIndex>& WindowNameIds() const; 2726 const std::deque<uint64_t>& WindowIds() const; 2727 const std::deque<DataIndex>& ModuleNameIds() const; 2728 const std::deque<DataIndex>& CategoryNameIds() const; 2729 const std::deque<uint64_t>& Sizes() const; 2730 const std::deque<uint32_t>& Counts() const; 2731 const std::deque<uint64_t>& PurgeableSizes() const; Clear()2732 void Clear() override 2733 { 2734 CacheBase::Clear(); 2735 windowNameIds_.clear(); 2736 windowIds_.clear(); 2737 moduleNameIds_.clear(); 2738 categoryNameIds_.clear(); 2739 sizes_.clear(); 2740 counts_.clear(); 2741 purgeableSizes_.clear(); 2742 } 2743 2744 private: 2745 std::deque<DataIndex> windowNameIds_ = {}; 2746 std::deque<uint64_t> windowIds_ = {}; 2747 std::deque<DataIndex> moduleNameIds_ = {}; 2748 std::deque<DataIndex> categoryNameIds_ = {}; 2749 std::deque<uint64_t> sizes_ = {}; 2750 std::deque<uint32_t> counts_ = {}; 2751 std::deque<uint64_t> purgeableSizes_ = {}; 2752 uint32_t rowCount_ = 0; 2753 }; 2754 2755 } // namespace TraceStdtype 2756 } // namespace SysTuning 2757 2758 #endif // TRACE_STDTYPE_H 2759