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 #include "activity_monitor_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendNewHidumpInfo(uint64_t timeStamp,uint32_t fps)19 size_t Hidump::AppendNewHidumpInfo(uint64_t timeStamp, uint32_t fps)
20 {
21 timeStamps_.emplace_back(timeStamp);
22 fpss_.emplace_back(fps);
23 return Size() - 1;
24 }
Fpss() const25 const std::deque<uint32_t>& Hidump::Fpss() const
26 {
27 return fpss_;
28 }
Clear()29 void Hidump::Clear()
30 {
31 CacheBase::Clear();
32 fpss_.clear();
33 }
34
AppendNewData(uint64_t ts,uint64_t dur,uint64_t rd,uint64_t wr,uint64_t rdPerSec,uint64_t wrPerSec,double rdCountPerSec,double wrCountPerSec,uint64_t rdCount,uint64_t wrCount)35 void DiskIOData::AppendNewData(uint64_t ts,
36 uint64_t dur,
37 uint64_t rd,
38 uint64_t wr,
39 uint64_t rdPerSec,
40 uint64_t wrPerSec,
41 double rdCountPerSec,
42 double wrCountPerSec,
43 uint64_t rdCount,
44 uint64_t wrCount)
45 {
46 timeStamps_.emplace_back(ts);
47 durs_.emplace_back(dur);
48 rdDatas_.emplace_back(rd);
49 wrDatas_.emplace_back(wr);
50 rdPerSec_.emplace_back(rdPerSec);
51 wrPerSec_.emplace_back(wrPerSec);
52 rdCountPerSec_.emplace_back(rdCountPerSec);
53 wrCountPerSec_.emplace_back(wrCountPerSec);
54 rdCountDatas_.emplace_back(rdCount);
55 wrCountDatas_.emplace_back(wrCount);
56 }
Durs() const57 const std::deque<uint64_t>& DiskIOData::Durs() const
58 {
59 return durs_;
60 }
RdDatas() const61 const std::deque<uint64_t>& DiskIOData::RdDatas() const
62 {
63 return rdDatas_;
64 }
WrDatas() const65 const std::deque<uint64_t>& DiskIOData::WrDatas() const
66 {
67 return wrDatas_;
68 }
RdSpeedDatas() const69 const std::deque<double>& DiskIOData::RdSpeedDatas() const
70 {
71 return rdPerSec_;
72 }
WrSpeedDatas() const73 const std::deque<double>& DiskIOData::WrSpeedDatas() const
74 {
75 return wrPerSec_;
76 }
77
RdCountPerSecDatas() const78 const std::deque<double>& DiskIOData::RdCountPerSecDatas() const
79 {
80 return rdCountPerSec_;
81 }
WrCountPerSecDatas() const82 const std::deque<double>& DiskIOData::WrCountPerSecDatas() const
83 {
84 return wrCountPerSec_;
85 }
RdCountDatas() const86 const std::deque<uint64_t>& DiskIOData::RdCountDatas() const
87 {
88 return rdCountDatas_;
89 }
WrCountDatas() const90 const std::deque<uint64_t>& DiskIOData::WrCountDatas() const
91 {
92 return wrCountDatas_;
93 }
Clear()94 void DiskIOData::Clear()
95 {
96 CacheBase::Clear();
97 durs_.clear();
98 rdDatas_.clear();
99 wrDatas_.clear();
100 wrPerSec_.clear();
101 rdPerSec_.clear();
102 wrCountPerSec_.clear();
103 rdCountPerSec_.clear();
104 rdCountDatas_.clear();
105 wrCountDatas_.clear();
106 }
107
AppendNewData(uint64_t newTimeStamp,uint64_t dur,int32_t processID,std::string processName,int32_t parentProcessID,int32_t uid,std::string userName,double cpuUsage,int32_t pssInfo,uint64_t cpuTime,int32_t threads,int64_t diskWrites,int64_t diskReads)108 size_t LiveProcessDetailData::AppendNewData(uint64_t newTimeStamp,
109 uint64_t dur,
110 int32_t processID,
111 std::string processName,
112 int32_t parentProcessID,
113 int32_t uid,
114 std::string userName,
115 double cpuUsage,
116 int32_t pssInfo,
117 uint64_t cpuTime,
118 int32_t threads,
119 int64_t diskWrites,
120 int64_t diskReads)
121 {
122 timeStamps_.emplace_back(newTimeStamp);
123 durs_.emplace_back(dur);
124 processID_.emplace_back(processID);
125 processName_.emplace_back(processName);
126 parentProcessID_.emplace_back(parentProcessID);
127 uid_.emplace_back(uid);
128 userName_.emplace_back(userName);
129 cpuUsage_.emplace_back(cpuUsage);
130 pssInfo_.emplace_back(pssInfo);
131 threads_.emplace_back(threads);
132 diskWrites_.emplace_back(diskWrites);
133 diskReads_.emplace_back(diskReads);
134 cpuTimes_.emplace_back(cpuTime);
135 return Size() - 1;
136 }
Durs() const137 const std::deque<uint64_t>& LiveProcessDetailData::Durs() const
138 {
139 return durs_;
140 }
ProcessID() const141 const std::deque<int32_t>& LiveProcessDetailData::ProcessID() const
142 {
143 return processID_;
144 }
ProcessName() const145 const std::deque<std::string>& LiveProcessDetailData::ProcessName() const
146 {
147 return processName_;
148 }
ParentProcessID() const149 const std::deque<int32_t>& LiveProcessDetailData::ParentProcessID() const
150 {
151 return parentProcessID_;
152 }
Uid() const153 const std::deque<int32_t>& LiveProcessDetailData::Uid() const
154 {
155 return uid_;
156 }
UserName() const157 const std::deque<std::string>& LiveProcessDetailData::UserName() const
158 {
159 return userName_;
160 }
CpuUsage() const161 const std::deque<double>& LiveProcessDetailData::CpuUsage() const
162 {
163 return cpuUsage_;
164 }
PssInfo() const165 const std::deque<int32_t>& LiveProcessDetailData::PssInfo() const
166 {
167 return pssInfo_;
168 }
Threads() const169 const std::deque<int32_t>& LiveProcessDetailData::Threads() const
170 {
171 return threads_;
172 }
DiskWrites() const173 const std::deque<int64_t>& LiveProcessDetailData::DiskWrites() const
174 {
175 return diskWrites_;
176 }
DiskReads() const177 const std::deque<int64_t>& LiveProcessDetailData::DiskReads() const
178 {
179 return diskReads_;
180 }
181
CpuTimes() const182 const std::deque<uint64_t>& LiveProcessDetailData::CpuTimes() const
183 {
184 return cpuTimes_;
185 }
Clear()186 void LiveProcessDetailData::Clear()
187 {
188 CacheBase::Clear();
189 durs_.clear();
190 processID_.clear();
191 processName_.clear();
192 parentProcessID_.clear();
193 uid_.clear();
194 userName_.clear();
195 cpuUsage_.clear();
196 pssInfo_.clear();
197 threads_.clear();
198 diskWrites_.clear();
199 diskReads_.clear();
200 }
201
AppendNewData(uint64_t newTimeStamp,uint64_t dur,double totalLoad,double userLoad,double systemLoad,int64_t threads)202 size_t CpuUsageDetailData::AppendNewData(uint64_t newTimeStamp,
203 uint64_t dur,
204 double totalLoad,
205 double userLoad,
206 double systemLoad,
207 int64_t threads)
208 {
209 timeStamps_.emplace_back(newTimeStamp);
210 durs_.emplace_back(dur);
211 totalLoad_.emplace_back(totalLoad);
212 userLoad_.emplace_back(userLoad);
213 systemLoad_.emplace_back(systemLoad);
214 threads_.emplace_back(threads);
215 return Size() - 1;
216 }
Durs() const217 const std::deque<uint64_t>& CpuUsageDetailData::Durs() const
218 {
219 return durs_;
220 }
TotalLoad() const221 const std::deque<double>& CpuUsageDetailData::TotalLoad() const
222 {
223 return totalLoad_;
224 }
UserLoad() const225 const std::deque<double>& CpuUsageDetailData::UserLoad() const
226 {
227 return userLoad_;
228 }
SystemLoad() const229 const std::deque<double>& CpuUsageDetailData::SystemLoad() const
230 {
231 return systemLoad_;
232 }
Threads() const233 const std::deque<int64_t>& CpuUsageDetailData::Threads() const
234 {
235 return threads_;
236 }
Clear()237 void CpuUsageDetailData::Clear()
238 {
239 CacheBase::Clear();
240 durs_.clear();
241 totalLoad_.clear();
242 userLoad_.clear();
243 systemLoad_.clear();
244 threads_.clear();
245 }
246
AppendNewNetData(uint64_t newTimeStamp,uint64_t tx,uint64_t rx,uint64_t dur,double rxSpeed,double txSpeed,uint64_t packetIn,double packetInSec,uint64_t packetOut,double packetOutSec,const std::string & netType)247 size_t NetDetailData::AppendNewNetData(uint64_t newTimeStamp,
248 uint64_t tx,
249 uint64_t rx,
250 uint64_t dur,
251 double rxSpeed,
252 double txSpeed,
253 uint64_t packetIn,
254 double packetInSec,
255 uint64_t packetOut,
256 double packetOutSec,
257 const std::string& netType)
258 {
259 timeStamps_.emplace_back(newTimeStamp);
260 txs_.emplace_back(tx);
261 rxs_.emplace_back(rx);
262 durs_.emplace_back(dur);
263 txSpeeds_.emplace_back(txSpeed);
264 rxSpeeds_.emplace_back(rxSpeed);
265 netTypes_.emplace_back(netType);
266 packetIn_.emplace_back(packetIn);
267 packetInSec_.emplace_back(packetInSec);
268 packetOut_.emplace_back(packetOut);
269 packetOutSec_.emplace_back(packetOutSec);
270
271 return Size() - 1;
272 }
Durs() const273 const std::deque<uint64_t>& NetDetailData::Durs() const
274 {
275 return durs_;
276 }
RxSpeed() const277 const std::deque<double>& NetDetailData::RxSpeed() const
278 {
279 return rxSpeeds_;
280 }
TxSpeed() const281 const std::deque<double>& NetDetailData::TxSpeed() const
282 {
283 return txSpeeds_;
284 }
NetTypes() const285 const std::deque<std::string>& NetDetailData::NetTypes() const
286 {
287 return netTypes_;
288 }
RxDatas() const289 const std::deque<uint64_t>& NetDetailData::RxDatas() const
290 {
291 return rxs_;
292 }
TxDatas() const293 const std::deque<uint64_t>& NetDetailData::TxDatas() const
294 {
295 return txs_;
296 }
PacketIn() const297 const std::deque<uint64_t>& NetDetailData::PacketIn() const
298 {
299 return packetIn_;
300 }
PacketInSec() const301 const std::deque<double>& NetDetailData::PacketInSec() const
302 {
303 return packetInSec_;
304 }
PacketOut() const305 const std::deque<uint64_t>& NetDetailData::PacketOut() const
306 {
307 return packetOut_;
308 }
PacketOutSec() const309 const std::deque<double>& NetDetailData::PacketOutSec() const
310 {
311 return packetOutSec_;
312 }
Clear()313 void NetDetailData::Clear()
314 {
315 CacheBase::Clear();
316 durs_.clear();
317 rxSpeeds_.clear();
318 txSpeeds_.clear();
319 netTypes_.clear();
320 packetIn_.clear();
321 packetInSec_.clear();
322 packetOut_.clear();
323 packetOutSec_.clear();
324 }
325
AppendNewData(uint64_t timeStamp,uint64_t ipid,std::string startAddr,std::string endAddr,uint64_t dirty,uint64_t swapper,uint64_t rss,uint64_t pss,uint64_t size,double reside,DataIndex protectionId,DataIndex pathId,uint64_t sharedClean,uint64_t sharedDirty,uint64_t privateClean,uint64_t privateDirty,uint64_t swap,uint64_t swapPss,uint32_t type)326 void SmapsData::AppendNewData(uint64_t timeStamp,
327 uint64_t ipid,
328 std::string startAddr,
329 std::string endAddr,
330 uint64_t dirty,
331 uint64_t swapper,
332 uint64_t rss,
333 uint64_t pss,
334 uint64_t size,
335 double reside,
336 DataIndex protectionId,
337 DataIndex pathId,
338 uint64_t sharedClean,
339 uint64_t sharedDirty,
340 uint64_t privateClean,
341 uint64_t privateDirty,
342 uint64_t swap,
343 uint64_t swapPss,
344 uint32_t type)
345 {
346 timeStamps_.emplace_back(timeStamp);
347 ipids_.emplace_back(ipid);
348 startAddrs_.emplace_back(startAddr);
349 endAddrs_.emplace_back(endAddr);
350 dirtys_.emplace_back(dirty);
351 swappers_.emplace_back(swapper);
352 rss_.emplace_back(rss);
353 pss_.emplace_back(pss);
354 sizes_.emplace_back(size);
355 resides_.emplace_back(reside);
356 protectionIds_.emplace_back(protectionId);
357 pathIds_.emplace_back(pathId);
358 sharedClean_.emplace_back(sharedClean);
359 sharedDirty_.emplace_back(sharedDirty);
360 privateClean_.emplace_back(privateClean);
361 privateDirty_.emplace_back(privateDirty);
362 swap_.emplace_back(swap);
363 swapPss_.emplace_back(swapPss);
364 type_.emplace_back(type);
365 ids_.emplace_back(rowCount_);
366 rowCount_++;
367 }
TimeStamps() const368 const std::deque<uint64_t>& SmapsData::TimeStamps() const
369 {
370 return timeStamps_;
371 }
Ipids() const372 const std::deque<uint64_t>& SmapsData::Ipids() const
373 {
374 return ipids_;
375 }
StartAddrs() const376 const std::deque<std::string>& SmapsData::StartAddrs() const
377 {
378 return startAddrs_;
379 }
EndAddrs() const380 const std::deque<std::string>& SmapsData::EndAddrs() const
381 {
382 return endAddrs_;
383 }
Dirtys() const384 const std::deque<uint64_t>& SmapsData::Dirtys() const
385 {
386 return dirtys_;
387 }
Swappers() const388 const std::deque<uint64_t>& SmapsData::Swappers() const
389 {
390 return swappers_;
391 }
Rss() const392 const std::deque<uint64_t>& SmapsData::Rss() const
393 {
394 return rss_;
395 }
Pss() const396 const std::deque<uint64_t>& SmapsData::Pss() const
397 {
398 return pss_;
399 }
Sizes() const400 const std::deque<uint64_t>& SmapsData::Sizes() const
401 {
402 return sizes_;
403 }
Resides() const404 const std::deque<double>& SmapsData::Resides() const
405 {
406 return resides_;
407 }
ProtectionIds() const408 const std::deque<DataIndex>& SmapsData::ProtectionIds() const
409 {
410 return protectionIds_;
411 }
PathIds() const412 const std::deque<DataIndex>& SmapsData::PathIds() const
413 {
414 return pathIds_;
415 }
SharedClean() const416 const std::deque<uint64_t>& SmapsData::SharedClean() const
417 {
418 return sharedClean_;
419 }
SharedDirty() const420 const std::deque<uint64_t>& SmapsData::SharedDirty() const
421 {
422 return sharedDirty_;
423 }
PrivateClean() const424 const std::deque<uint64_t>& SmapsData::PrivateClean() const
425 {
426 return privateClean_;
427 }
PrivateDirty() const428 const std::deque<uint64_t>& SmapsData::PrivateDirty() const
429 {
430 return privateDirty_;
431 }
Swap() const432 const std::deque<uint64_t>& SmapsData::Swap() const
433 {
434 return swap_;
435 }
SwapPss() const436 const std::deque<uint64_t>& SmapsData::SwapPss() const
437 {
438 return swapPss_;
439 }
Type() const440 const std::deque<uint32_t>& SmapsData::Type() const
441 {
442 return type_;
443 }
Clear()444 void SmapsData::Clear()
445 {
446 CacheBase::Clear();
447 ipids_.clear();
448 startAddrs_.clear();
449 endAddrs_.clear();
450 dirtys_.clear();
451 swappers_.clear();
452 rss_.clear();
453 pss_.clear();
454 sizes_.clear();
455 resides_.clear();
456 protectionIds_.clear();
457 pathIds_.clear();
458 sharedClean_.clear();
459 sharedDirty_.clear();
460 privateClean_.clear();
461 privateDirty_.clear();
462 swap_.clear();
463 swapPss_.clear();
464 type_.clear();
465 }
466
AppendNewData(InternalPid ipid,uint64_t ts,uint32_t adj,uint32_t fd,DataIndex ashmemNameId,uint64_t size,uint64_t pss,uint32_t ashmemId,uint64_t time,uint64_t refCount,uint64_t purged,uint32_t flag)467 void AshMemData::AppendNewData(InternalPid ipid,
468 uint64_t ts,
469 uint32_t adj,
470 uint32_t fd,
471 DataIndex ashmemNameId,
472 uint64_t size,
473 uint64_t pss,
474 uint32_t ashmemId,
475 uint64_t time,
476 uint64_t refCount,
477 uint64_t purged,
478 uint32_t flag)
479 {
480 ipids_.emplace_back(ipid);
481 timeStamps_.emplace_back(ts);
482 adjs_.emplace_back(adj);
483 fds_.emplace_back(fd);
484 ashmemNameIds_.emplace_back(ashmemNameId);
485 sizes_.emplace_back(size);
486 psss_.emplace_back(pss);
487 ashmemIds_.emplace_back(ashmemId);
488 times_.emplace_back(time);
489 refCounts_.emplace_back(refCount);
490 purgeds_.emplace_back(purged);
491 flags_.emplace_back(flag);
492 ids_.emplace_back(rowCount_);
493 rowCount_++;
494 }
SetFlag(uint64_t rowId,uint32_t flag)495 void AshMemData::SetFlag(uint64_t rowId, uint32_t flag)
496 {
497 flags_[rowId] = flag;
498 }
Ipids() const499 const std::deque<InternalPid>& AshMemData::Ipids() const
500 {
501 return ipids_;
502 }
Adjs() const503 const std::deque<uint32_t>& AshMemData::Adjs() const
504 {
505 return adjs_;
506 }
Fds() const507 const std::deque<uint32_t>& AshMemData::Fds() const
508 {
509 return fds_;
510 }
AshmemNameIds() const511 const std::deque<DataIndex>& AshMemData::AshmemNameIds() const
512 {
513 return ashmemNameIds_;
514 }
Sizes() const515 const std::deque<uint64_t>& AshMemData::Sizes() const
516 {
517 return sizes_;
518 }
Psss() const519 const std::deque<uint64_t>& AshMemData::Psss() const
520 {
521 return psss_;
522 }
AshmemIds() const523 const std::deque<uint32_t>& AshMemData::AshmemIds() const
524 {
525 return ashmemIds_;
526 }
Times() const527 const std::deque<uint64_t>& AshMemData::Times() const
528 {
529 return times_;
530 }
RefCounts() const531 const std::deque<uint64_t>& AshMemData::RefCounts() const
532 {
533 return refCounts_;
534 }
Purgeds() const535 const std::deque<uint64_t>& AshMemData::Purgeds() const
536 {
537 return purgeds_;
538 }
Flags() const539 const std::deque<uint32_t>& AshMemData::Flags() const
540 {
541 return flags_;
542 }
Clear()543 void AshMemData::Clear()
544 {
545 CacheBase::Clear();
546 ipids_.clear();
547 adjs_.clear();
548 fds_.clear();
549 ashmemNameIds_.clear();
550 sizes_.clear();
551 psss_.clear();
552 ashmemIds_.clear();
553 times_.clear();
554 refCounts_.clear();
555 purgeds_.clear();
556 flags_.clear();
557 }
558
AppendNewData(InternalPid ipid,uint64_t ts,uint32_t fd,uint64_t size,uint32_t ino,uint32_t expPid,DataIndex expTaskCommId,DataIndex bufNameId,DataIndex expNameId,uint32_t flag)559 void DmaMemData::AppendNewData(InternalPid ipid,
560 uint64_t ts,
561 uint32_t fd,
562 uint64_t size,
563 uint32_t ino,
564 uint32_t expPid,
565 DataIndex expTaskCommId,
566 DataIndex bufNameId,
567 DataIndex expNameId,
568 uint32_t flag)
569 {
570 ipids_.emplace_back(ipid);
571 timeStamps_.emplace_back(ts);
572 fds_.emplace_back(fd);
573 sizes_.emplace_back(size);
574 inos_.emplace_back(ino);
575 expPids_.emplace_back(expPid);
576 expTaskCommIds_.emplace_back(expTaskCommId);
577 bufNameIds_.emplace_back(bufNameId);
578 expNameIds_.emplace_back(expNameId);
579 flags_.emplace_back(flag);
580 ids_.emplace_back(rowCount_);
581 rowCount_++;
582 }
SetFlag(uint64_t rowId,uint32_t flag)583 void DmaMemData::SetFlag(uint64_t rowId, uint32_t flag)
584 {
585 flags_[rowId] = flag;
586 }
Ipids() const587 const std::deque<InternalPid>& DmaMemData::Ipids() const
588 {
589 return ipids_;
590 }
Fds() const591 const std::deque<uint32_t>& DmaMemData::Fds() const
592 {
593 return fds_;
594 }
Sizes() const595 const std::deque<uint64_t>& DmaMemData::Sizes() const
596 {
597 return sizes_;
598 }
Inos() const599 const std::deque<uint32_t>& DmaMemData::Inos() const
600 {
601 return inos_;
602 }
ExpPids() const603 const std::deque<uint32_t>& DmaMemData::ExpPids() const
604 {
605 return expPids_;
606 }
ExpTaskCommIds() const607 const std::deque<DataIndex>& DmaMemData::ExpTaskCommIds() const
608 {
609 return expTaskCommIds_;
610 }
BufNameIds() const611 const std::deque<DataIndex>& DmaMemData::BufNameIds() const
612 {
613 return bufNameIds_;
614 }
ExpNameIds() const615 const std::deque<DataIndex>& DmaMemData::ExpNameIds() const
616 {
617 return expNameIds_;
618 }
Flags() const619 const std::deque<uint32_t>& DmaMemData::Flags() const
620 {
621 return flags_;
622 }
Clear()623 void DmaMemData::Clear()
624 {
625 CacheBase::Clear();
626 ipids_.clear();
627 fds_.clear();
628 sizes_.clear();
629 inos_.clear();
630 expPids_.clear();
631 expTaskCommIds_.clear();
632 bufNameIds_.clear();
633 expNameIds_.clear();
634 flags_.clear();
635 }
636
AppendNewData(uint64_t ts,DataIndex gpuNameId,uint64_t allGpuSize,std::string addr,InternalPid ipid,InternalPid itid,uint64_t usedGpuSize)637 void GpuProcessMemData::AppendNewData(uint64_t ts,
638 DataIndex gpuNameId,
639 uint64_t allGpuSize,
640 std::string addr,
641 InternalPid ipid,
642 InternalPid itid,
643 uint64_t usedGpuSize)
644 {
645 timeStamps_.emplace_back(ts);
646 gpuNameIds_.emplace_back(gpuNameId);
647 allGpuSizes_.emplace_back(allGpuSize);
648 addrs_.emplace_back(addr);
649 ipids_.emplace_back(ipid);
650 itids_.emplace_back(itid);
651 usedGpuSizes_.emplace_back(usedGpuSize);
652 ids_.emplace_back(rowCount_);
653 rowCount_++;
654 }
GpuNameIds() const655 const std::deque<DataIndex>& GpuProcessMemData::GpuNameIds() const
656 {
657 return gpuNameIds_;
658 }
AllGpuSizes() const659 const std::deque<uint64_t>& GpuProcessMemData::AllGpuSizes() const
660 {
661 return allGpuSizes_;
662 }
Addrs() const663 const std::deque<std::string>& GpuProcessMemData::Addrs() const
664 {
665 return addrs_;
666 }
Ipids() const667 const std::deque<InternalPid>& GpuProcessMemData::Ipids() const
668 {
669 return ipids_;
670 }
Itids() const671 const std::deque<InternalPid>& GpuProcessMemData::Itids() const
672 {
673 return itids_;
674 }
UsedGpuSizes() const675 const std::deque<uint64_t>& GpuProcessMemData::UsedGpuSizes() const
676 {
677 return usedGpuSizes_;
678 }
Clear()679 void GpuProcessMemData::Clear()
680 {
681 CacheBase::Clear();
682 gpuNameIds_.clear();
683 allGpuSizes_.clear();
684 addrs_.clear();
685 ipids_.clear();
686 itids_.clear();
687 usedGpuSizes_.clear();
688 }
AppendNewData(uint64_t ts,DataIndex windowNameId,uint64_t windowId,DataIndex moduleNameId,DataIndex categoryNameId,uint64_t size,uint32_t count,uint64_t purgeableSize)689 void GpuWindowMemData::AppendNewData(uint64_t ts,
690 DataIndex windowNameId,
691 uint64_t windowId,
692 DataIndex moduleNameId,
693 DataIndex categoryNameId,
694 uint64_t size,
695 uint32_t count,
696 uint64_t purgeableSize)
697 {
698 timeStamps_.emplace_back(ts);
699 windowNameIds_.emplace_back(windowNameId);
700 windowIds_.emplace_back(windowId);
701 moduleNameIds_.emplace_back(moduleNameId);
702 categoryNameIds_.emplace_back(categoryNameId);
703 sizes_.emplace_back(size);
704 counts_.emplace_back(count);
705 purgeableSizes_.emplace_back(purgeableSize);
706 ipids_.emplace_back(INVALID_IPID);
707 ids_.emplace_back(rowCount_);
708 rowCount_++;
709 }
WindowNameIds() const710 const std::deque<DataIndex>& GpuWindowMemData::WindowNameIds() const
711 {
712 return windowNameIds_;
713 }
WindowIds() const714 const std::deque<uint64_t>& GpuWindowMemData::WindowIds() const
715 {
716 return windowIds_;
717 }
ModuleNameIds() const718 const std::deque<DataIndex>& GpuWindowMemData::ModuleNameIds() const
719 {
720 return moduleNameIds_;
721 }
CategoryNameIds() const722 const std::deque<DataIndex>& GpuWindowMemData::CategoryNameIds() const
723 {
724 return categoryNameIds_;
725 }
Sizes() const726 const std::deque<uint64_t>& GpuWindowMemData::Sizes() const
727 {
728 return sizes_;
729 }
Counts() const730 const std::deque<uint32_t>& GpuWindowMemData::Counts() const
731 {
732 return counts_;
733 }
PurgeableSizes() const734 const std::deque<uint64_t>& GpuWindowMemData::PurgeableSizes() const
735 {
736 return purgeableSizes_;
737 }
Ipids() const738 const std::deque<InternalPid>& GpuWindowMemData::Ipids() const
739 {
740 return ipids_;
741 }
Clear()742 void GpuWindowMemData::Clear()
743 {
744 CacheBase::Clear();
745 windowNameIds_.clear();
746 windowIds_.clear();
747 moduleNameIds_.clear();
748 categoryNameIds_.clear();
749 sizes_.clear();
750 counts_.clear();
751 purgeableSizes_.clear();
752 ipids_.clear();
753 }
RevicesIpid(const std::map<DataIndex,InternalPid> & windowIdToIpidMap)754 void GpuWindowMemData::RevicesIpid(const std::map<DataIndex, InternalPid>& windowIdToIpidMap)
755 {
756 for (auto i = 0; i < Size(); i++) {
757 if (windowIdToIpidMap.count(windowNameIds_[i])) {
758 ipids_[i] = windowIdToIpidMap.at(windowNameIds_[i]);
759 }
760 }
761 }
762
AppendNewData(uint64_t timestamp,uint64_t size)763 void CpuDumpInfo::AppendNewData(uint64_t timestamp, uint64_t size)
764 {
765 timeStamps_.emplace_back(timestamp);
766 totalSizes_.emplace_back(size);
767 ids_.emplace_back(Size());
768 }
TotalSizes() const769 const std::deque<uint64_t>& CpuDumpInfo::TotalSizes() const
770 {
771 return totalSizes_;
772 }
Clear()773 void CpuDumpInfo::Clear()
774 {
775 CacheBase::Clear();
776 totalSizes_.clear();
777 }
778
AppendNewData(uint64_t timestamp,DataIndex channelIndex,uint64_t size)779 void ProfileMemInfo::AppendNewData(uint64_t timestamp, DataIndex channelIndex, uint64_t size)
780 {
781 timeStamps_.emplace_back(timestamp);
782 totalSizes_.emplace_back(size);
783 channelIndexs_.emplace_back(channelIndex);
784 ids_.emplace_back(Size());
785 }
ChannelIndexs() const786 const std::deque<uint64_t>& ProfileMemInfo::ChannelIndexs() const
787 {
788 return channelIndexs_;
789 }
TotalSizes() const790 const std::deque<uint64_t>& ProfileMemInfo::TotalSizes() const
791 {
792 return totalSizes_;
793 }
Clear()794 void ProfileMemInfo::Clear()
795 {
796 CacheBase::Clear();
797 channelIndexs_.clear();
798 totalSizes_.clear();
799 }
800
AppendNewData(uint64_t timestamp,uint64_t memSize,DataIndex typeIndex,InternalPid ipid,DataIndex name)801 void RSImageDumpInfo::AppendNewData(uint64_t timestamp,
802 uint64_t memSize,
803 DataIndex typeIndex,
804 InternalPid ipid,
805 DataIndex name)
806 {
807 timeStamps_.emplace_back(timestamp);
808 memSizes_.emplace_back(memSize);
809 typeIndexs_.emplace_back(typeIndex);
810 ipids_.emplace_back(ipid);
811 surfaceNameIndexs_.emplace_back(name);
812 ids_.emplace_back(Size());
813 }
MemSizes() const814 const std::deque<uint64_t>& RSImageDumpInfo::MemSizes() const
815 {
816 return memSizes_;
817 }
TypeIndexs() const818 const std::deque<DataIndex>& RSImageDumpInfo::TypeIndexs() const
819 {
820 return typeIndexs_;
821 }
Ipids() const822 const std::deque<InternalPid>& RSImageDumpInfo::Ipids() const
823 {
824 return ipids_;
825 }
SurfaceNameIndexs() const826 const std::deque<DataIndex>& RSImageDumpInfo::SurfaceNameIndexs() const
827 {
828 return surfaceNameIndexs_;
829 }
Clear()830 void RSImageDumpInfo::Clear()
831 {
832 CacheBase::Clear();
833 memSizes_.clear();
834 typeIndexs_.clear();
835 ipids_.clear();
836 surfaceNameIndexs_.clear();
837 }
838 } // namespace TraceStdtype
839 } // namespace SysTuning
840