1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "trace_stdtype.h"
17 #include <algorithm>
18 #include <cmath>
19 #include <ctime>
20 #include "string_to_numerical.h"
21 namespace SysTuning {
22 namespace TraceStdtype {
23 constexpr int32_t MAX_SIZE_LEN = 80;
24 constexpr uint8_t DEVICEINFO_MATCH_LAST = 2;
25 #define UNUSED(expr) \
26 do { \
27 static_cast<void>(expr); \
28 } while (0)
SetDur(uint64_t index,uint64_t dur)29 void CpuCacheBase::SetDur(uint64_t index, uint64_t dur)
30 {
31 durs_[index] = dur;
32 }
AppendThreadState(InternalTime ts,InternalTime dur,InternalCpu cpu,InternalTid itid,TableRowId idState)33 TableRowId ThreadStateData::AppendThreadState(InternalTime ts,
34 InternalTime dur,
35 InternalCpu cpu,
36 InternalTid itid,
37 TableRowId idState)
38 {
39 timeStamps_.emplace_back(ts);
40 durations_.emplace_back(dur);
41 itids_.emplace_back(itid);
42 tids_.emplace_back(INVALID_UINT32);
43 pids_.emplace_back(INVALID_UINT32);
44 states_.emplace_back(idState);
45 cpus_.emplace_back(cpu);
46 argSetIds_.emplace_back(INVALID_UINT32);
47 return itids_.size() - 1;
48 }
49
SetDuration(TableRowId index,InternalTime dur)50 void ThreadStateData::SetDuration(TableRowId index, InternalTime dur)
51 {
52 durations_[index] = dur;
53 }
Finish()54 void DataDict::Finish()
55 {
56 std::string::size_type pos(0);
57 for (auto i = 0; i < dataDict_.size(); i++) {
58 if (dataDict_[i].empty()) {
59 continue;
60 }
61 while ((pos = dataDict_[i].find("\"")) != std::string::npos) {
62 dataDict_[i].replace(pos, 1, "\'");
63 }
64 while ((dataDict_[i].back() >= SPASCII_START && dataDict_[i].back() <= SPASCII_END) ||
65 dataDict_[i].back() == '\r') {
66 dataDict_[i].pop_back();
67 }
68 }
69 }
UpdateDuration(TableRowId index,InternalTime ts)70 TableRowId ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts)
71 {
72 if (durations_[index] == INVALID_TIME) {
73 durations_[index] = ts - timeStamps_[index];
74 }
75 return itids_[index];
76 }
77
End(TableRowId index,InternalTime ts)78 bool ThreadStateData::End(TableRowId index, InternalTime ts)
79 {
80 if (durations_[index] == INVALID_TIME) {
81 durations_[index] = -1;
82 return false;
83 }
84 return true;
85 }
UpdateState(TableRowId index,TableRowId idState)86 void ThreadStateData::UpdateState(TableRowId index, TableRowId idState)
87 {
88 states_[index] = idState;
89 }
SetArgSetId(TableRowId index,uint32_t setId)90 void ThreadStateData::SetArgSetId(TableRowId index, uint32_t setId)
91 {
92 argSetIds_[index] = setId;
93 }
94
UpdateDuration(TableRowId index,InternalTime ts,TableRowId idState)95 void ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts, TableRowId idState)
96 {
97 durations_[index] = ts - timeStamps_[index];
98 states_[index] = idState;
99 }
100
UpdateTidAndPid(TableRowId index,InternalTid tid,InternalTid pid)101 void ThreadStateData::UpdateTidAndPid(TableRowId index, InternalTid tid, InternalTid pid)
102 {
103 tids_[index] = tid;
104 pids_[index] = pid;
105 }
106
UpdateDuration(TableRowId index,InternalTime ts,InternalCpu cpu,TableRowId idState)107 TableRowId ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts, InternalCpu cpu, TableRowId idState)
108 {
109 cpus_[index] = cpu;
110 durations_[index] = ts - timeStamps_[index];
111 states_[index] = idState;
112 return itids_[index];
113 }
114
AppendSchedSlice(uint64_t ts,uint64_t dur,uint64_t cpu,uint32_t internalTid,uint64_t endState,uint64_t priority)115 size_t SchedSlice::AppendSchedSlice(uint64_t ts,
116 uint64_t dur,
117 uint64_t cpu,
118 uint32_t internalTid,
119 uint64_t endState,
120 uint64_t priority)
121 {
122 timeStamps_.emplace_back(ts);
123 durs_.emplace_back(dur);
124 cpus_.emplace_back(cpu);
125 tsEnds_.emplace_back(0);
126 internalTids_.emplace_back(internalTid);
127 endStates_.emplace_back(endState);
128 priority_.emplace_back(priority);
129 argSets_.emplace_back(INVALID_UINT32);
130 return Size() - 1;
131 }
132
SetDuration(size_t index,uint64_t duration)133 void SchedSlice::SetDuration(size_t index, uint64_t duration)
134 {
135 durs_[index] = duration;
136 tsEnds_[index] = timeStamps_[index] + duration;
137 }
138
Update(uint64_t index,uint64_t ts,uint64_t state)139 void SchedSlice::Update(uint64_t index, uint64_t ts, uint64_t state)
140 {
141 durs_[index] = ts - timeStamps_[index];
142 endStates_[index] = state;
143 }
144
UpdateArg(uint64_t index,uint32_t argsetId)145 void SchedSlice::UpdateArg(uint64_t index, uint32_t argsetId)
146 {
147 argSets_[index] = argsetId;
148 }
AppendInternalAsyncSlice(uint64_t startT,uint64_t durationNs,InternalTid internalTid,DataIndex cat,uint16_t nameIdentify,DataIndex name,uint8_t depth,uint64_t cookid,const std::optional<uint64_t> & parentId)149 size_t CallStack::AppendInternalAsyncSlice(uint64_t startT,
150 uint64_t durationNs,
151 InternalTid internalTid,
152 DataIndex cat,
153 uint16_t nameIdentify,
154 DataIndex name,
155 uint8_t depth,
156 uint64_t cookid,
157 const std::optional<uint64_t>& parentId)
158 {
159 AppendCommonInfo(startT, durationNs, internalTid);
160 AppendCallStack(cat, name, depth, parentId);
161 AppendDistributeInfo();
162 cookies_.emplace_back(cookid);
163 ids_.emplace_back(ids_.size());
164 identifys_.emplace_back(nameIdentify + depth);
165 return Size() - 1;
166 }
AppendInternalSlice(uint64_t startT,uint64_t durationNs,InternalTid internalTid,DataIndex cat,uint16_t nameIdentify,DataIndex name,uint8_t depth,const std::optional<uint64_t> & parentId)167 size_t CallStack::AppendInternalSlice(uint64_t startT,
168 uint64_t durationNs,
169 InternalTid internalTid,
170 DataIndex cat,
171 uint16_t nameIdentify,
172 DataIndex name,
173 uint8_t depth,
174 const std::optional<uint64_t>& parentId)
175 {
176 AppendCommonInfo(startT, durationNs, internalTid);
177 AppendCallStack(cat, name, depth, parentId);
178 identifys_.emplace_back(nameIdentify + depth);
179 ids_.emplace_back(ids_.size());
180 cookies_.emplace_back(INVALID_UINT64);
181 AppendDistributeInfo();
182 return Size() - 1;
183 }
184
AppendCommonInfo(uint64_t startT,uint64_t durationNs,InternalTid internalTid)185 void CallStack::AppendCommonInfo(uint64_t startT, uint64_t durationNs, InternalTid internalTid)
186 {
187 timeStamps_.emplace_back(startT);
188 durs_.emplace_back(durationNs);
189 callIds_.emplace_back(internalTid);
190 }
AppendCallStack(DataIndex cat,DataIndex name,uint8_t depth,std::optional<uint64_t> parentId)191 void CallStack::AppendCallStack(DataIndex cat, DataIndex name, uint8_t depth, std::optional<uint64_t> parentId)
192 {
193 parentIds_.emplace_back(parentId);
194 cats_.emplace_back(cat);
195 names_.emplace_back(name);
196 depths_.emplace_back(depth);
197 }
SetDistributeInfo(size_t index,const std::string & chainId,const std::string & spanId,const std::string & parentSpanId,const std::string & flag,const std::string & args)198 void CallStack::SetDistributeInfo(size_t index,
199 const std::string& chainId,
200 const std::string& spanId,
201 const std::string& parentSpanId,
202 const std::string& flag,
203 const std::string& args)
204 {
205 chainIds_[index] = chainId;
206 spanIds_[index] = spanId;
207 parentSpanIds_[index] = parentSpanId;
208 flags_[index] = flag;
209 args_[index] = args;
210 argSet_[index] = INVALID_UINT32;
211 }
AppendDistributeInfo(const std::string & chainId,const std::string & spanId,const std::string & parentSpanId,const std::string & flag,const std::string & args)212 void CallStack::AppendDistributeInfo(const std::string& chainId,
213 const std::string& spanId,
214 const std::string& parentSpanId,
215 const std::string& flag,
216 const std::string& args)
217 {
218 chainIds_.emplace_back(chainId);
219 spanIds_.emplace_back(spanId);
220 parentSpanIds_.emplace_back(parentSpanId);
221 flags_.emplace_back(flag);
222 args_.emplace_back(args);
223 argSet_.emplace_back(INVALID_UINT32);
224 }
AppendDistributeInfo()225 void CallStack::AppendDistributeInfo()
226 {
227 chainIds_.emplace_back("");
228 spanIds_.emplace_back("");
229 parentSpanIds_.emplace_back("");
230 flags_.emplace_back("");
231 args_.emplace_back("");
232 argSet_.emplace_back(INVALID_UINT32);
233 }
SetDuration(size_t index,uint64_t timeStamp)234 void CallStack::SetDuration(size_t index, uint64_t timeStamp)
235 {
236 durs_[index] = timeStamp - timeStamps_[index];
237 }
SetDurationWithFlag(size_t index,uint64_t timeStamp)238 void CallStack::SetDurationWithFlag(size_t index, uint64_t timeStamp)
239 {
240 durs_[index] = timeStamp - timeStamps_[index];
241 flags_[index] = "1";
242 }
243
SetFlag(size_t index,uint8_t flag)244 void CallStack::SetFlag(size_t index, uint8_t flag)
245 {
246 flags_[index] = std::to_string(flag);
247 }
SetDurationEx(size_t index,uint32_t dur)248 void CallStack::SetDurationEx(size_t index, uint32_t dur)
249 {
250 durs_[index] = dur;
251 }
252
SetIrqDurAndArg(size_t index,uint64_t timeStamp,uint32_t argSetId)253 void CallStack::SetIrqDurAndArg(size_t index, uint64_t timeStamp, uint32_t argSetId)
254 {
255 SetDuration(index, timeStamp);
256 argSet_[index] = argSetId;
257 }
SetTimeStamp(size_t index,uint64_t timeStamp)258 void CallStack::SetTimeStamp(size_t index, uint64_t timeStamp)
259 {
260 timeStamps_[index] = timeStamp;
261 }
262
SetDepth(size_t index,uint8_t depth)263 void CallStack::SetDepth(size_t index, uint8_t depth)
264 {
265 depths_[index] = depth;
266 }
SetArgSetId(size_t index,uint32_t argSetId)267 void CallStack::SetArgSetId(size_t index, uint32_t argSetId)
268 {
269 argSet_[index] = argSetId;
270 }
ParentIdData() const271 const std::deque<std::optional<uint64_t>>& CallStack::ParentIdData() const
272 {
273 return parentIds_;
274 }
CatsData() const275 const std::deque<DataIndex>& CallStack::CatsData() const
276 {
277 return cats_;
278 }
IdentifysData() const279 const std::deque<uint16_t>& CallStack::IdentifysData() const
280 {
281 return identifys_;
282 }
NamesData() const283 const std::deque<DataIndex>& CallStack::NamesData() const
284 {
285 return names_;
286 }
Depths() const287 const std::deque<uint8_t>& CallStack::Depths() const
288 {
289 return depths_;
290 }
Cookies() const291 const std::deque<uint64_t>& CallStack::Cookies() const
292 {
293 return cookies_;
294 }
CallIds() const295 const std::deque<uint32_t>& CallStack::CallIds() const
296 {
297 return callIds_;
298 }
ChainIds() const299 const std::deque<std::string>& CallStack::ChainIds() const
300 {
301 return chainIds_;
302 }
SpanIds() const303 const std::deque<std::string>& CallStack::SpanIds() const
304 {
305 return spanIds_;
306 }
ParentSpanIds() const307 const std::deque<std::string>& CallStack::ParentSpanIds() const
308 {
309 return parentSpanIds_;
310 }
Flags() const311 const std::deque<std::string>& CallStack::Flags() const
312 {
313 return flags_;
314 }
ArgsData() const315 const std::deque<std::string>& CallStack::ArgsData() const
316 {
317 return args_;
318 }
ArgSetIdsData() const319 const std::deque<uint32_t>& CallStack::ArgSetIdsData() const
320 {
321 return argSet_;
322 }
323
AppendNewArg(DataIndex nameId,BaseDataType dataType,int64_t value,size_t argSet)324 size_t ArgSet::AppendNewArg(DataIndex nameId, BaseDataType dataType, int64_t value, size_t argSet)
325 {
326 dataTypes_.emplace_back(dataType);
327 argset_.emplace_back(argSet);
328 ids_.emplace_back(Size());
329 values_.emplace_back(value);
330 names_.emplace_back(nameId);
331 return Size() - 1;
332 }
DataTypes() const333 const std::deque<BaseDataType>& ArgSet::DataTypes() const
334 {
335 return dataTypes_;
336 }
ValuesData() const337 const std::deque<int64_t>& ArgSet::ValuesData() const
338 {
339 return values_;
340 }
ArgsData() const341 const std::deque<uint64_t>& ArgSet::ArgsData() const
342 {
343 return argset_;
344 }
NamesData() const345 const std::deque<DataIndex>& ArgSet::NamesData() const
346 {
347 return names_;
348 }
349
AppendNewFilter(uint64_t filterId,DataIndex type,DataIndex nameId)350 size_t SysMeasureFilter::AppendNewFilter(uint64_t filterId, DataIndex type, DataIndex nameId)
351 {
352 ids_.emplace_back(filterId);
353 names_.emplace_back(nameId);
354 types_.emplace_back(type);
355 return ids_.size() - 1;
356 }
NamesData() const357 const std::deque<DataIndex>& SysMeasureFilter::NamesData() const
358 {
359 return names_;
360 }
361
TypesData() const362 const std::deque<DataIndex>& SysMeasureFilter::TypesData() const
363 {
364 return types_;
365 }
AppendNewDataType(BaseDataType dataType,DataIndex dataDescIndex)366 size_t DataType::AppendNewDataType(BaseDataType dataType, DataIndex dataDescIndex)
367 {
368 ids_.emplace_back(Size());
369 dataTypes_.emplace_back(dataType);
370 descs_.emplace_back(dataDescIndex);
371 return Size() - 1;
372 }
373
DataTypes() const374 const std::deque<BaseDataType>& DataType::DataTypes() const
375 {
376 return dataTypes_;
377 }
DataDesc() const378 const std::deque<DataIndex>& DataType::DataDesc() const
379 {
380 return descs_;
381 }
AppendNewFilterData(std::string type,std::string name,uint64_t sourceArgSetId)382 size_t Filter::AppendNewFilterData(std::string type, std::string name, uint64_t sourceArgSetId)
383 {
384 nameDeque_.emplace_back(name);
385 sourceArgSetId_.emplace_back(sourceArgSetId);
386 ids_.emplace_back(Size());
387 typeDeque_.emplace_back(type);
388 return Size() - 1;
389 }
390
AppendMeasureData(uint32_t type,uint64_t timeStamp,int64_t value,uint32_t filterId)391 size_t Measure::AppendMeasureData(uint32_t type, uint64_t timeStamp, int64_t value, uint32_t filterId)
392 {
393 valuesDeque_.emplace_back(value);
394 filterIdDeque_.emplace_back(filterId);
395 typeDeque_.emplace_back(type);
396 timeStamps_.emplace_back(timeStamp);
397 durDeque_.emplace_back(INVALID_UINT64);
398 return Size() - 1;
399 }
400
SetDur(uint32_t row,uint64_t timeStamp)401 void Measure::SetDur(uint32_t row, uint64_t timeStamp)
402 {
403 durDeque_[row] = timeStamp - timeStamps_[row];
404 }
AppendRawData(uint32_t id,uint64_t timeStamp,uint32_t name,uint32_t cpu,uint32_t internalTid)405 size_t Raw::AppendRawData(uint32_t id, uint64_t timeStamp, uint32_t name, uint32_t cpu, uint32_t internalTid)
406 {
407 ids_.emplace_back(id);
408 timeStamps_.emplace_back(timeStamp);
409 nameDeque_.emplace_back(name);
410 cpuDeque_.emplace_back(cpu);
411 itidDeque_.emplace_back(internalTid);
412 return Size() - 1;
413 }
414
AppendNewFilter(uint64_t filterId,uint32_t nameIndex,uint64_t internalTid)415 size_t ThreadMeasureFilter::AppendNewFilter(uint64_t filterId, uint32_t nameIndex, uint64_t internalTid)
416 {
417 filterId_.emplace_back(filterId);
418 nameIndex_.emplace_back(nameIndex);
419 internalTids_.emplace_back(internalTid);
420 return Size() - 1;
421 }
422
AppendInstantEventData(uint64_t timeStamp,DataIndex nameIndex,int64_t internalTid,int64_t wakeupFromInternalPid)423 size_t Instants::AppendInstantEventData(uint64_t timeStamp,
424 DataIndex nameIndex,
425 int64_t internalTid,
426 int64_t wakeupFromInternalPid)
427 {
428 internalTids_.emplace_back(internalTid);
429 timeStamps_.emplace_back(timeStamp);
430 NameIndexs_.emplace_back(nameIndex);
431 wakeupFromInternalPids_.emplace_back(wakeupFromInternalPid);
432 return Size() - 1;
433 }
AppendNewLogInfo(uint64_t seq,uint64_t timeStamp,uint32_t pid,uint32_t tid,DataIndex level,DataIndex tag,DataIndex context,uint64_t originTs)434 size_t LogInfo::AppendNewLogInfo(uint64_t seq,
435 uint64_t timeStamp,
436 uint32_t pid,
437 uint32_t tid,
438 DataIndex level,
439 DataIndex tag,
440 DataIndex context,
441 uint64_t originTs)
442 {
443 hilogLineSeqs_.emplace_back(seq);
444 timeStamps_.emplace_back(timeStamp);
445 pids_.emplace_back(pid);
446 tids_.emplace_back(tid);
447 levels_.emplace_back(level);
448 tags_.emplace_back(tag);
449 contexts_.emplace_back(context);
450 originTs_.emplace_back(originTs);
451 return Size() - 1;
452 }
HilogLineSeqs() const453 const std::deque<uint64_t>& LogInfo::HilogLineSeqs() const
454 {
455 return hilogLineSeqs_;
456 }
Pids() const457 const std::deque<uint32_t>& LogInfo::Pids() const
458 {
459 return pids_;
460 }
Tids() const461 const std::deque<uint32_t>& LogInfo::Tids() const
462 {
463 return tids_;
464 }
Levels() const465 const std::deque<DataIndex>& LogInfo::Levels() const
466 {
467 return levels_;
468 }
Tags() const469 const std::deque<DataIndex>& LogInfo::Tags() const
470 {
471 return tags_;
472 }
Contexts() const473 const std::deque<DataIndex>& LogInfo::Contexts() const
474 {
475 return contexts_;
476 }
OriginTimeStamData() const477 const std::deque<uint64_t>& LogInfo::OriginTimeStamData() const
478 {
479 return originTs_;
480 }
UpdateCallChainId(size_t row,uint32_t callChainId)481 void NativeHook::UpdateCallChainId(size_t row, uint32_t callChainId)
482 {
483 if (row < Size()) {
484 callChainIds_[row] = callChainId;
485 } else {
486 TS_LOGE("Native hook update callChainId failed!!!");
487 }
488 }
AppendNewNativeHookData(uint32_t callChainId,uint32_t ipid,uint32_t itid,std::string eventType,DataIndex subType,uint64_t timeStamp,uint64_t endTimeStamp,uint64_t duration,uint64_t addr,int64_t memSize)489 size_t NativeHook::AppendNewNativeHookData(uint32_t callChainId,
490 uint32_t ipid,
491 uint32_t itid,
492 std::string eventType,
493 DataIndex subType,
494 uint64_t timeStamp,
495 uint64_t endTimeStamp,
496 uint64_t duration,
497 uint64_t addr,
498 int64_t memSize)
499 {
500 callChainIds_.emplace_back(callChainId);
501 ipids_.emplace_back(ipid);
502 itids_.emplace_back(itid);
503 eventTypes_.emplace_back(eventType);
504 subTypes_.emplace_back(subType);
505 timeStamps_.emplace_back(timeStamp);
506 endTimeStamps_.emplace_back(endTimeStamp);
507 durations_.emplace_back(duration);
508 addrs_.emplace_back(addr);
509 memSizes_.emplace_back(memSize);
510 if (eventType == ALLOC_EVET) {
511 countHeapSizes_ += memSize;
512 allMemSizes_.emplace_back(countHeapSizes_);
513 } else if (eventType == FREE_EVENT) {
514 countHeapSizes_ -= memSize;
515 allMemSizes_.emplace_back(countHeapSizes_);
516 } else if (eventType == MMAP_EVENT) {
517 countMmapSizes_ += memSize;
518 allMemSizes_.emplace_back(countMmapSizes_);
519 } else if (eventType == MUNMAP_EVENT) {
520 countMmapSizes_ -= memSize;
521 allMemSizes_.emplace_back(countMmapSizes_);
522 }
523 currentSizeDurs_.emplace_back(0);
524 lastCallerPathIndexs_.emplace_back(INVALID_UINT64);
525 return Size() - 1;
526 }
UpdateEndTimeStampAndDuration(size_t row,uint64_t endTimeStamp)527 void NativeHook::UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp)
528 {
529 endTimeStamps_[row] = endTimeStamp;
530 durations_[row] = endTimeStamp - timeStamps_[row];
531 }
UpdateCurrentSizeDur(size_t row,uint64_t timeStamp)532 void NativeHook::UpdateCurrentSizeDur(size_t row, uint64_t timeStamp)
533 {
534 currentSizeDurs_[row] = timeStamp - timeStamps_[row];
535 }
UpdateMemMapSubType(uint64_t row,uint64_t tagId)536 void NativeHook::UpdateMemMapSubType(uint64_t row, uint64_t tagId)
537 {
538 if (row < subTypes_.size()) {
539 subTypes_[row] = tagId;
540 } else {
541 TS_LOGE("subTypes_ row is invalid!");
542 }
543 }
UpdateLastCallerPathIndexs(std::unordered_map<uint32_t,uint64_t> & callIdToLasLibId)544 void NativeHook::UpdateLastCallerPathIndexs(std::unordered_map<uint32_t, uint64_t>& callIdToLasLibId)
545 {
546 if (callIdToLasLibId.empty()) {
547 return;
548 }
549 for (auto i = 0; i < Size(); ++i) {
550 auto symbolIt = callIdToLasLibId.find(callChainIds_[i]);
551 if (symbolIt != callIdToLasLibId.end()) {
552 lastCallerPathIndexs_[i] = symbolIt->second;
553 } else {
554 lastCallerPathIndexs_[i] = INVALID_UINT64;
555 }
556 }
557 }
CallChainIds() const558 const std::deque<uint32_t>& NativeHook::CallChainIds() const
559 {
560 return callChainIds_;
561 }
Ipids() const562 const std::deque<uint32_t>& NativeHook::Ipids() const
563 {
564 return ipids_;
565 }
Itids() const566 const std::deque<uint32_t>& NativeHook::Itids() const
567 {
568 return itids_;
569 }
EventTypes() const570 const std::deque<std::string>& NativeHook::EventTypes() const
571 {
572 return eventTypes_;
573 }
SubTypes() const574 const std::deque<DataIndex>& NativeHook::SubTypes() const
575 {
576 return subTypes_;
577 }
EndTimeStamps() const578 const std::deque<uint64_t>& NativeHook::EndTimeStamps() const
579 {
580 return endTimeStamps_;
581 }
Durations() const582 const std::deque<uint64_t>& NativeHook::Durations() const
583 {
584 return durations_;
585 }
Addrs() const586 const std::deque<uint64_t>& NativeHook::Addrs() const
587 {
588 return addrs_;
589 }
MemSizes() const590 const std::deque<int64_t>& NativeHook::MemSizes() const
591 {
592 return memSizes_;
593 }
AllMemSizes() const594 const std::deque<int64_t>& NativeHook::AllMemSizes() const
595 {
596 return allMemSizes_;
597 }
CurrentSizeDurs() const598 const std::deque<uint64_t>& NativeHook::CurrentSizeDurs() const
599 {
600 return currentSizeDurs_;
601 }
LastCallerPathIndexs() const602 const std::deque<uint64_t>& NativeHook::LastCallerPathIndexs() const
603 {
604 return lastCallerPathIndexs_;
605 }
AppendNewNativeHookFrame(uint32_t callChainId,uint64_t depth,uint64_t ip,uint64_t sp,DataIndex symbolName,DataIndex filePath,uint64_t offset,uint64_t symbolOffset,const std::string & vaddr)606 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
607 uint64_t depth,
608 uint64_t ip,
609 uint64_t sp,
610 DataIndex symbolName,
611 DataIndex filePath,
612 uint64_t offset,
613 uint64_t symbolOffset,
614 const std::string& vaddr)
615 {
616 callChainIds_.emplace_back(callChainId);
617 ips_.emplace_back(ip);
618 sps_.emplace_back(sp);
619 depths_.emplace_back(depth);
620 symbolNames_.emplace_back(symbolName);
621 filePaths_.emplace_back(filePath);
622 offsets_.emplace_back(offset);
623 symbolOffsets_.emplace_back(symbolOffset);
624 vaddrs_.emplace_back(vaddr);
625 return Size() - 1;
626 }
AppendNewNativeHookFrame(uint32_t callChainId,uint64_t depth,uint64_t ip,uint64_t sp,DataIndex symbolName,DataIndex filePath,uint64_t offset,uint64_t symbolOffset)627 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
628 uint64_t depth,
629 uint64_t ip,
630 uint64_t sp,
631 DataIndex symbolName,
632 DataIndex filePath,
633 uint64_t offset,
634 uint64_t symbolOffset)
635 {
636 callChainIds_.emplace_back(callChainId);
637 ips_.emplace_back(ip);
638 sps_.emplace_back(sp);
639 depths_.emplace_back(depth);
640 symbolNames_.emplace_back(symbolName);
641 filePaths_.emplace_back(filePath);
642 offsets_.emplace_back(offset);
643 symbolOffsets_.emplace_back(symbolOffset);
644 return Size() - 1;
645 }
UpdateSymbolIdToNameMap(uint64_t originSymbolId,uint64_t symbolId)646 void NativeHookFrame::UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId)
647 {
648 symbolIdToSymbolName_.insert(std::make_pair(originSymbolId, symbolId));
649 }
UpdateFrameInfo(size_t row,DataIndex symbolIndex,DataIndex filePathIndex,uint64_t offset,uint64_t symbolOffset)650 void NativeHookFrame::UpdateFrameInfo(size_t row,
651 DataIndex symbolIndex,
652 DataIndex filePathIndex,
653 uint64_t offset,
654 uint64_t symbolOffset)
655 {
656 if (row >= Size()) {
657 TS_LOGE("The updated row does not exist!");
658 return;
659 }
660 symbolNames_[row] = symbolIndex;
661 filePaths_[row] = filePathIndex;
662 offsets_[row] = offset;
663 symbolOffsets_[row] = symbolOffset;
664 }
665
UpdateSymbolId()666 void NativeHookFrame::UpdateSymbolId()
667 {
668 if (symbolIdToSymbolName_.empty()) {
669 return;
670 }
671 for (auto i = 0; i < Size(); ++i) {
672 auto symbolIt = symbolIdToSymbolName_.find(symbolNames_[i]);
673 if (symbolIt != symbolIdToSymbolName_.end()) {
674 symbolNames_[i] = symbolIt->second;
675 }
676 }
677 }
UpdateSymbolId(size_t index,DataIndex symbolId)678 void NativeHookFrame::UpdateSymbolId(size_t index, DataIndex symbolId)
679 {
680 if (index < Size()) {
681 symbolNames_[index] = symbolId;
682 }
683 }
UpdateFileId(std::map<uint32_t,uint64_t> & filePathIdToFilePathName)684 void NativeHookFrame::UpdateFileId(std::map<uint32_t, uint64_t>& filePathIdToFilePathName)
685 {
686 if (filePathIdToFilePathName.empty()) {
687 return;
688 }
689 for (auto i = 0; i < Size(); ++i) {
690 auto symbolIt = filePathIdToFilePathName.find(filePaths_[i]);
691 if (symbolIt != filePathIdToFilePathName.end()) {
692 filePaths_[i] = symbolIt->second;
693 }
694 }
695 }
UpdateVaddrs(std::deque<std::string> & vaddrs)696 void NativeHookFrame::UpdateVaddrs(std::deque<std::string>& vaddrs)
697 {
698 vaddrs_.assign(vaddrs.begin(), vaddrs.end());
699 }
CallChainIds() const700 const std::deque<uint32_t>& NativeHookFrame::CallChainIds() const
701 {
702 return callChainIds_;
703 }
Depths() const704 const std::deque<uint64_t>& NativeHookFrame::Depths() const
705 {
706 return depths_;
707 }
Ips() const708 const std::deque<uint64_t>& NativeHookFrame::Ips() const
709 {
710 return ips_;
711 }
Sps() const712 const std::deque<uint64_t>& NativeHookFrame::Sps() const
713 {
714 return sps_;
715 }
SymbolNames() const716 const std::deque<DataIndex>& NativeHookFrame::SymbolNames() const
717 {
718 return symbolNames_;
719 }
FilePaths() const720 const std::deque<DataIndex>& NativeHookFrame::FilePaths() const
721 {
722 return filePaths_;
723 }
Offsets() const724 const std::deque<uint64_t>& NativeHookFrame::Offsets() const
725 {
726 return offsets_;
727 }
SymbolOffsets() const728 const std::deque<uint64_t>& NativeHookFrame::SymbolOffsets() const
729 {
730 return symbolOffsets_;
731 }
Vaddrs() const732 const std::deque<std::string>& NativeHookFrame::Vaddrs() const
733 {
734 return vaddrs_;
735 }
736
AppendNewNativeHookStatistic(uint32_t ipid,uint64_t timeStamp,uint32_t callChainId,uint32_t memoryType,DataIndex subMemType,uint64_t applyCount,uint64_t releaseCount,uint64_t applySize,uint64_t releaseSize)737 size_t NativeHookStatistic::AppendNewNativeHookStatistic(uint32_t ipid,
738 uint64_t timeStamp,
739 uint32_t callChainId,
740 uint32_t memoryType,
741 DataIndex subMemType,
742 uint64_t applyCount,
743 uint64_t releaseCount,
744 uint64_t applySize,
745 uint64_t releaseSize)
746 {
747 ids_.emplace_back(Size());
748 ipids_.emplace_back(ipid);
749 timeStamps_.emplace_back(timeStamp);
750 callChainIds_.emplace_back(callChainId);
751 memoryTypes_.emplace_back(memoryType);
752 applyCounts_.emplace_back(applyCount);
753 memSubTypes_.emplace_back(subMemType);
754 releaseCounts_.emplace_back(releaseCount);
755 applySizes_.emplace_back(applySize);
756 releaseSizes_.emplace_back(releaseSize);
757 return Size() - 1;
758 }
Ipids() const759 const std::deque<uint32_t>& NativeHookStatistic::Ipids() const
760 {
761 return ipids_;
762 }
CallChainIds() const763 const std::deque<uint32_t>& NativeHookStatistic::CallChainIds() const
764 {
765 return callChainIds_;
766 }
MemoryTypes() const767 const std::deque<uint32_t>& NativeHookStatistic::MemoryTypes() const
768 {
769 return memoryTypes_;
770 }
MemorySubTypes() const771 const std::deque<DataIndex>& NativeHookStatistic::MemorySubTypes() const
772 {
773 return memSubTypes_;
774 }
ApplyCounts() const775 const std::deque<uint64_t>& NativeHookStatistic::ApplyCounts() const
776 {
777 return applyCounts_;
778 }
ReleaseCounts() const779 const std::deque<uint64_t>& NativeHookStatistic::ReleaseCounts() const
780 {
781 return releaseCounts_;
782 }
ApplySizes() const783 const std::deque<uint64_t>& NativeHookStatistic::ApplySizes() const
784 {
785 return applySizes_;
786 }
ReleaseSizes() const787 const std::deque<uint64_t>& NativeHookStatistic::ReleaseSizes() const
788 {
789 return releaseSizes_;
790 }
AppendNewHidumpInfo(uint64_t timeStamp,uint32_t fps)791 size_t Hidump::AppendNewHidumpInfo(uint64_t timeStamp, uint32_t fps)
792 {
793 timeStamps_.emplace_back(timeStamp);
794 fpss_.emplace_back(fps);
795 return Size() - 1;
796 }
Fpss() const797 const std::deque<uint32_t>& Hidump::Fpss() const
798 {
799 return fpss_;
800 }
801
AppendNewPerfCallChain(uint64_t sampleId,uint32_t callChainId,uint64_t vaddrInFile,uint64_t fileId,uint64_t symbolId)802 size_t PerfCallChain::AppendNewPerfCallChain(uint64_t sampleId,
803 uint32_t callChainId,
804 uint64_t vaddrInFile,
805 uint64_t fileId,
806 uint64_t symbolId)
807 {
808 ids_.emplace_back(Size());
809 sampleIds_.emplace_back(sampleId);
810 callChainIds_.emplace_back(callChainId);
811 vaddrInFiles_.emplace_back(vaddrInFile);
812 fileIds_.emplace_back(fileId);
813 symbolIds_.emplace_back(symbolId);
814 names_.emplace_back("");
815 return Size() - 1;
816 }
SampleIds() const817 const std::deque<uint64_t>& PerfCallChain::SampleIds() const
818 {
819 return sampleIds_;
820 }
CallChainIds() const821 const std::deque<uint32_t>& PerfCallChain::CallChainIds() const
822 {
823 return callChainIds_;
824 }
VaddrInFiles() const825 const std::deque<uint64_t>& PerfCallChain::VaddrInFiles() const
826 {
827 return vaddrInFiles_;
828 }
FileIds() const829 const std::deque<uint64_t>& PerfCallChain::FileIds() const
830 {
831 return fileIds_;
832 }
SymbolIds() const833 const std::deque<uint64_t>& PerfCallChain::SymbolIds() const
834 {
835 return symbolIds_;
836 }
837
Names() const838 const std::deque<std::string>& PerfCallChain::Names() const
839 {
840 return names_;
841 }
SetName(uint64_t index,const std::string & name)842 void PerfCallChain::SetName(uint64_t index, const std::string& name)
843 {
844 names_[index] = name;
845 }
Clear()846 void PerfCallChain::Clear()
847 {
848 CacheBase::Clear();
849 sampleIds_.clear();
850 callChainIds_.clear();
851 vaddrInFiles_.clear();
852 fileIds_.clear();
853 symbolIds_.clear();
854 names_.clear();
855 }
AppendNewPerfFiles(uint64_t fileIds,uint32_t serial,DataIndex symbols,DataIndex filePath)856 size_t PerfFiles::AppendNewPerfFiles(uint64_t fileIds, uint32_t serial, DataIndex symbols, DataIndex filePath)
857 {
858 ids_.emplace_back(Size());
859 fileIds_.emplace_back(fileIds);
860 serials_.emplace_back(serial);
861 symbols_.emplace_back(symbols);
862 filePaths_.emplace_back(filePath);
863 return Size() - 1;
864 }
FileIds() const865 const std::deque<uint64_t>& PerfFiles::FileIds() const
866 {
867 return fileIds_;
868 }
869
Serials() const870 const std::deque<uint32_t>& PerfFiles::Serials() const
871 {
872 return serials_;
873 }
Symbols() const874 const std::deque<DataIndex>& PerfFiles::Symbols() const
875 {
876 return symbols_;
877 }
FilePaths() const878 const std::deque<DataIndex>& PerfFiles::FilePaths() const
879 {
880 return filePaths_;
881 }
882
Clear()883 void PerfFiles::Clear()
884 {
885 CacheBase::Clear();
886 fileIds_.clear();
887 serials_.clear();
888 symbols_.clear();
889 filePaths_.clear();
890 }
891
AppendNewPerfSample(uint32_t sampleId,uint64_t timeStamp,uint32_t tid,uint64_t eventCount,uint64_t eventTypeId,uint64_t timestampTrace,uint64_t cpuId,uint64_t threadState)892 size_t PerfSample::AppendNewPerfSample(uint32_t sampleId,
893 uint64_t timeStamp,
894 uint32_t tid,
895 uint64_t eventCount,
896 uint64_t eventTypeId,
897 uint64_t timestampTrace,
898 uint64_t cpuId,
899 uint64_t threadState)
900 {
901 ids_.emplace_back(Size());
902 sampleIds_.emplace_back(sampleId);
903 timeStamps_.emplace_back(timeStamp);
904 tids_.emplace_back(tid);
905 eventCounts_.emplace_back(eventCount);
906 eventTypeIds_.emplace_back(eventTypeId);
907 timestampTraces_.emplace_back(timestampTrace);
908 cpuIds_.emplace_back(cpuId);
909 threadStates_.emplace_back(threadState);
910 return Size() - 1;
911 }
SampleIds() const912 const std::deque<uint32_t>& PerfSample::SampleIds() const
913 {
914 return sampleIds_;
915 }
Tids() const916 const std::deque<uint32_t>& PerfSample::Tids() const
917 {
918 return tids_;
919 }
EventCounts() const920 const std::deque<uint64_t>& PerfSample::EventCounts() const
921 {
922 return eventCounts_;
923 }
EventTypeIds() const924 const std::deque<uint64_t>& PerfSample::EventTypeIds() const
925 {
926 return eventTypeIds_;
927 }
TimestampTraces() const928 const std::deque<uint64_t>& PerfSample::TimestampTraces() const
929 {
930 return timestampTraces_;
931 }
CpuIds() const932 const std::deque<uint64_t>& PerfSample::CpuIds() const
933 {
934 return cpuIds_;
935 }
ThreadStates() const936 const std::deque<DataIndex>& PerfSample::ThreadStates() const
937 {
938 return threadStates_;
939 }
940
Clear()941 void PerfSample::Clear()
942 {
943 CacheBase::Clear();
944 sampleIds_.clear();
945 tids_.clear();
946 eventCounts_.clear();
947 eventTypeIds_.clear();
948 timestampTraces_.clear();
949 cpuIds_.clear();
950 threadStates_.clear();
951 }
952
AppendNewPerfThread(uint32_t pid,uint32_t tid,DataIndex threadName)953 size_t PerfThread::AppendNewPerfThread(uint32_t pid, uint32_t tid, DataIndex threadName)
954 {
955 ids_.emplace_back(Size());
956 pids_.emplace_back(pid);
957 tids_.emplace_back(tid);
958 threadNames_.emplace_back(threadName);
959 return Size() - 1;
960 }
Pids() const961 const std::deque<uint32_t>& PerfThread::Pids() const
962 {
963 return pids_;
964 }
Tids() const965 const std::deque<uint32_t>& PerfThread::Tids() const
966 {
967 return tids_;
968 }
ThreadNames() const969 const std::deque<DataIndex>& PerfThread::ThreadNames() const
970 {
971 return threadNames_;
972 }
Clear()973 void PerfThread::Clear()
974 {
975 CacheBase::Clear();
976 tids_.clear();
977 pids_.clear();
978 threadNames_.clear();
979 }
AppendNewPerfReport(DataIndex type,DataIndex value)980 size_t PerfReport::AppendNewPerfReport(DataIndex type, DataIndex value)
981 {
982 ids_.emplace_back(Size());
983 types_.emplace_back(type);
984 values_.emplace_back(value);
985 return Size() - 1;
986 }
Types() const987 const std::deque<DataIndex>& PerfReport::Types() const
988 {
989 return types_;
990 }
Values() const991 const std::deque<DataIndex>& PerfReport::Values() const
992 {
993 return values_;
994 }
AppendNewFilter(uint64_t id,DataIndex name,uint32_t internalPid)995 size_t ProcessMeasureFilter::AppendNewFilter(uint64_t id, DataIndex name, uint32_t internalPid)
996 {
997 internalPids_.emplace_back(internalPid);
998 ids_.emplace_back(id);
999 names_.emplace_back(name);
1000 return Size() - 1;
1001 }
AppendNewFilter(uint64_t id,DataIndex type,DataIndex name,uint64_t cpu)1002 size_t ClockEventData::AppendNewFilter(uint64_t id, DataIndex type, DataIndex name, uint64_t cpu)
1003 {
1004 cpus_.emplace_back(cpu);
1005 ids_.emplace_back(id);
1006 types_.emplace_back(type);
1007 names_.emplace_back(name);
1008 return Size() - 1;
1009 }
AppendNewFilter(uint64_t id,uint64_t rate,DataIndex name,uint64_t cpu)1010 size_t ClkEventData::AppendNewFilter(uint64_t id, uint64_t rate, DataIndex name, uint64_t cpu)
1011 {
1012 ids_.emplace_back(id);
1013 rates_.emplace_back(rate);
1014 names_.emplace_back(name);
1015 cpus_.emplace_back(cpu);
1016 return Size() - 1;
1017 }
AppendSysCallData(int64_t sysCallNum,DataIndex type,uint32_t ipid,uint64_t timeStamp,int64_t ret)1018 size_t SysCall::AppendSysCallData(int64_t sysCallNum, DataIndex type, uint32_t ipid, uint64_t timeStamp, int64_t ret)
1019 {
1020 sysCallNums_.emplace_back(sysCallNum);
1021 types_.emplace_back(type);
1022 ipids_.emplace_back(ipid);
1023 timeStamps_.emplace_back(timeStamp);
1024 rets_.emplace_back(ret);
1025 return Size() - 1;
1026 }
StatAndInfo()1027 StatAndInfo::StatAndInfo()
1028 {
1029 // sched_switch_received | sched_switch_not_match | sched_switch_not_not_supported etc.
1030 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1031 event_[i] = config_.eventNameMap_.at(static_cast<SupportedTraceEventType>(i));
1032 }
1033 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1034 stat_[j] = config_.eventErrorDescMap_.at(static_cast<StatType>(j));
1035 }
1036
1037 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1038 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1039 statSeverity_[i][j] = config_.eventParserStatSeverityDescMap_.at(static_cast<SupportedTraceEventType>(i))
1040 .at(static_cast<StatType>(j));
1041 }
1042 }
1043
1044 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1045 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1046 statSeverityDesc_[i][j] = config_.serverityLevelDescMap_.at(statSeverity_[i][j]);
1047 }
1048 }
1049
1050 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1051 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1052 statCount_[i][j] = 0;
1053 }
1054 }
1055 clockid2ClockNameMap_ = {
1056 {TS_CLOCK_UNKNOW, "unknown"}, {TS_CLOCK_BOOTTIME, "boottime"},
1057 {TS_CLOCK_REALTIME, "realtime"}, {TS_CLOCK_REALTIME_COARSE, "realtime_corse"},
1058 {TS_MONOTONIC, "monotonic"}, {TS_MONOTONIC_COARSE, "monotonic-coarse"},
1059 {TS_MONOTONIC_RAW, "monotonic-raw"},
1060 };
1061 }
IncreaseStat(SupportedTraceEventType eventType,StatType type)1062 void StatAndInfo::IncreaseStat(SupportedTraceEventType eventType, StatType type)
1063 {
1064 statCount_[eventType][type]++;
1065 }
GetValue(SupportedTraceEventType eventType,StatType type) const1066 const uint32_t& StatAndInfo::GetValue(SupportedTraceEventType eventType, StatType type) const
1067 {
1068 return statCount_[eventType][type];
1069 }
GetEvent(SupportedTraceEventType eventType) const1070 const std::string& StatAndInfo::GetEvent(SupportedTraceEventType eventType) const
1071 {
1072 return event_[eventType];
1073 }
GetStat(StatType type) const1074 const std::string& StatAndInfo::GetStat(StatType type) const
1075 {
1076 return stat_[type];
1077 }
GetSeverityDesc(SupportedTraceEventType eventType,StatType type) const1078 const std::string& StatAndInfo::GetSeverityDesc(SupportedTraceEventType eventType, StatType type) const
1079 {
1080 return statSeverityDesc_[eventType][type];
1081 }
GetSeverity(SupportedTraceEventType eventType,StatType type) const1082 const StatSeverityLevel& StatAndInfo::GetSeverity(SupportedTraceEventType eventType, StatType type) const
1083 {
1084 return statSeverity_[eventType][type];
1085 }
1086
Size() const1087 uint64_t SymbolsData::Size() const
1088 {
1089 return addrs_.size();
1090 }
InsertSymbol(const DataIndex & name,const uint64_t & addr)1091 void SymbolsData::InsertSymbol(const DataIndex& name, const uint64_t& addr)
1092 {
1093 addrs_.emplace_back(addr);
1094 funcName_.emplace_back(name);
1095 }
GetConstFuncNames() const1096 const std::deque<DataIndex>& SymbolsData::GetConstFuncNames() const
1097 {
1098 return funcName_;
1099 }
GetConstAddrs() const1100 const std::deque<uint64_t>& SymbolsData::GetConstAddrs() const
1101 {
1102 return addrs_;
1103 }
MetaData()1104 MetaData::MetaData()
1105 {
1106 columnNames_.resize(METADATA_ITEM_MAX);
1107 values_.resize(METADATA_ITEM_MAX);
1108 columnNames_[METADATA_ITEM_DATASIZE] = METADATA_ITEM_DATASIZE_COLNAME;
1109 columnNames_[METADATA_ITEM_PARSETOOL_NAME] = METADATA_ITEM_PARSETOOL_NAME_COLNAME;
1110 columnNames_[METADATA_ITEM_PARSERTOOL_VERSION] = METADATA_ITEM_PARSERTOOL_VERSION_COLNAME;
1111 columnNames_[METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME] = METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME_COLNAME;
1112 columnNames_[METADATA_ITEM_SOURCE_FILENAME] = METADATA_ITEM_SOURCE_FILENAME_COLNAME;
1113 columnNames_[METADATA_ITEM_OUTPUT_FILENAME] = METADATA_ITEM_OUTPUT_FILENAME_COLNAME;
1114 columnNames_[METADATA_ITEM_PARSERTIME] = METADATA_ITEM_PARSERTIME_COLNAME;
1115 columnNames_[METADATA_ITEM_TRACE_DURATION] = METADATA_ITEM_TRACE_DURATION_COLNAME;
1116 columnNames_[METADATA_ITEM_SOURCE_DATETYPE] = METADATA_ITEM_SOURCE_DATETYPE_COLNAME;
1117 values_[METADATA_ITEM_PARSETOOL_NAME] = "trace_streamer";
1118 }
SetTraceType(const std::string & traceType)1119 void MetaData::SetTraceType(const std::string& traceType)
1120 {
1121 values_[METADATA_ITEM_SOURCE_DATETYPE] = traceType;
1122 }
SetSourceFileName(const std::string & fileName)1123 void MetaData::SetSourceFileName(const std::string& fileName)
1124 {
1125 MetaData::values_[METADATA_ITEM_SOURCE_FILENAME] = fileName;
1126 }
SetOutputFileName(const std::string & fileName)1127 void MetaData::SetOutputFileName(const std::string& fileName)
1128 {
1129 MetaData::values_[METADATA_ITEM_OUTPUT_FILENAME] = fileName;
1130 }
SetParserToolVersion(const std::string & version)1131 void MetaData::SetParserToolVersion(const std::string& version)
1132 {
1133 values_[METADATA_ITEM_PARSERTOOL_VERSION] = version;
1134 }
SetParserToolPublishDateTime(const std::string & datetime)1135 void MetaData::SetParserToolPublishDateTime(const std::string& datetime)
1136 {
1137 values_[METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME] = datetime;
1138 }
SetTraceDataSize(uint64_t dataSize)1139 void MetaData::SetTraceDataSize(uint64_t dataSize)
1140 {
1141 std::stringstream ss;
1142 ss << dataSize;
1143 values_[METADATA_ITEM_DATASIZE] = ss.str();
1144 // Function 'time' may return error. It is not allowed to do anything that might fail inside the constructor.
1145 time_t rawtime;
1146 struct tm* timeinfo = nullptr;
1147 void(time(&rawtime));
1148 timeinfo = localtime(&rawtime);
1149 char buffer[MAX_SIZE_LEN];
1150 strftime(buffer, MAX_SIZE_LEN, "%Y-%m-%d %H:%M:%S", timeinfo);
1151 values_[METADATA_ITEM_PARSERTIME].append(buffer);
1152 // sometimes there will be a extra \n at last
1153 values_[METADATA_ITEM_PARSERTIME].pop_back();
1154 }
SetTraceDuration(uint64_t dur)1155 void MetaData::SetTraceDuration(uint64_t dur)
1156 {
1157 values_[METADATA_ITEM_TRACE_DURATION] = std::to_string(dur) + " s";
1158 }
Value(uint64_t row) const1159 const std::string& MetaData::Value(uint64_t row) const
1160 {
1161 return values_[row];
1162 }
Name(uint64_t row) const1163 const std::string& MetaData::Name(uint64_t row) const
1164 {
1165 return columnNames_[row];
1166 }
GetStringIndex(std::string_view str)1167 DataIndex DataDict::GetStringIndex(std::string_view str)
1168 {
1169 auto hashValue = hashFun(str);
1170 auto itor = dataDictInnerMap_.find(hashValue);
1171 if (itor != dataDictInnerMap_.end()) {
1172 return itor->second;
1173 }
1174 mutex_.lock();
1175 dataDict_.emplace_back(std::string(str));
1176 DataIndex stringIdentity = dataDict_.size() - 1;
1177 dataDictInnerMap_.emplace(hashValue, stringIdentity);
1178 mutex_.unlock();
1179 return stringIdentity;
1180 }
GetStringIndexNoWrite(std::string_view str) const1181 DataIndex DataDict::GetStringIndexNoWrite(std::string_view str) const
1182 {
1183 auto hashValue = hashFun(str);
1184 auto itor = dataDictInnerMap_.find(hashValue);
1185 if (itor != dataDictInnerMap_.end()) {
1186 return itor->second;
1187 }
1188 return INVALID_UINT64;
1189 }
AppendNewData(uint64_t newTimeStamp,uint64_t dur,double totalLoad,double userLoad,double systemLoad,int64_t threads)1190 size_t CpuUsageDetailData::AppendNewData(uint64_t newTimeStamp,
1191 uint64_t dur,
1192 double totalLoad,
1193 double userLoad,
1194 double systemLoad,
1195 int64_t threads)
1196 {
1197 timeStamps_.emplace_back(newTimeStamp);
1198 durs_.emplace_back(dur);
1199 totalLoad_.emplace_back(totalLoad);
1200 userLoad_.emplace_back(userLoad);
1201 systemLoad_.emplace_back(systemLoad);
1202 threads_.emplace_back(threads);
1203 return Size() - 1;
1204 }
Durs() const1205 const std::deque<uint64_t>& CpuUsageDetailData::Durs() const
1206 {
1207 return durs_;
1208 }
TotalLoad() const1209 const std::deque<double>& CpuUsageDetailData::TotalLoad() const
1210 {
1211 return totalLoad_;
1212 }
UserLoad() const1213 const std::deque<double>& CpuUsageDetailData::UserLoad() const
1214 {
1215 return userLoad_;
1216 }
SystemLoad() const1217 const std::deque<double>& CpuUsageDetailData::SystemLoad() const
1218 {
1219 return systemLoad_;
1220 }
Threads() const1221 const std::deque<int64_t>& CpuUsageDetailData::Threads() const
1222 {
1223 return threads_;
1224 }
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)1225 size_t LiveProcessDetailData::AppendNewData(uint64_t newTimeStamp,
1226 uint64_t dur,
1227 int32_t processID,
1228 std::string processName,
1229 int32_t parentProcessID,
1230 int32_t uid,
1231 std::string userName,
1232 double cpuUsage,
1233 int32_t pssInfo,
1234 uint64_t cpuTime,
1235 int32_t threads,
1236 int64_t diskWrites,
1237 int64_t diskReads)
1238 {
1239 timeStamps_.emplace_back(newTimeStamp);
1240 durs_.emplace_back(dur);
1241 processID_.emplace_back(processID);
1242 processName_.emplace_back(processName);
1243 parentProcessID_.emplace_back(parentProcessID);
1244 uid_.emplace_back(uid);
1245 userName_.emplace_back(userName);
1246 cpuUsage_.emplace_back(cpuUsage);
1247 pssInfo_.emplace_back(pssInfo);
1248 threads_.emplace_back(threads);
1249 diskWrites_.emplace_back(diskWrites);
1250 diskReads_.emplace_back(diskReads);
1251 cpuTimes_.emplace_back(cpuTime);
1252 return Size() - 1;
1253 }
Durs() const1254 const std::deque<uint64_t>& LiveProcessDetailData::Durs() const
1255 {
1256 return durs_;
1257 }
ProcessID() const1258 const std::deque<int32_t>& LiveProcessDetailData::ProcessID() const
1259 {
1260 return processID_;
1261 }
ProcessName() const1262 const std::deque<std::string>& LiveProcessDetailData::ProcessName() const
1263 {
1264 return processName_;
1265 }
ParentProcessID() const1266 const std::deque<int32_t>& LiveProcessDetailData::ParentProcessID() const
1267 {
1268 return parentProcessID_;
1269 }
Uid() const1270 const std::deque<int32_t>& LiveProcessDetailData::Uid() const
1271 {
1272 return uid_;
1273 }
UserName() const1274 const std::deque<std::string>& LiveProcessDetailData::UserName() const
1275 {
1276 return userName_;
1277 }
CpuUsage() const1278 const std::deque<double>& LiveProcessDetailData::CpuUsage() const
1279 {
1280 return cpuUsage_;
1281 }
PssInfo() const1282 const std::deque<int32_t>& LiveProcessDetailData::PssInfo() const
1283 {
1284 return pssInfo_;
1285 }
Threads() const1286 const std::deque<int32_t>& LiveProcessDetailData::Threads() const
1287 {
1288 return threads_;
1289 }
DiskWrites() const1290 const std::deque<int64_t>& LiveProcessDetailData::DiskWrites() const
1291 {
1292 return diskWrites_;
1293 }
DiskReads() const1294 const std::deque<int64_t>& LiveProcessDetailData::DiskReads() const
1295 {
1296 return diskReads_;
1297 }
1298
CpuTimes() const1299 const std::deque<uint64_t>& LiveProcessDetailData::CpuTimes() const
1300 {
1301 return cpuTimes_;
1302 }
1303
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)1304 size_t NetDetailData::AppendNewNetData(uint64_t newTimeStamp,
1305 uint64_t tx,
1306 uint64_t rx,
1307 uint64_t dur,
1308 double rxSpeed,
1309 double txSpeed,
1310 uint64_t packetIn,
1311 double packetInSec,
1312 uint64_t packetOut,
1313 double packetOutSec,
1314 const std::string& netType)
1315 {
1316 timeStamps_.emplace_back(newTimeStamp);
1317 txs_.emplace_back(tx);
1318 rxs_.emplace_back(rx);
1319 durs_.emplace_back(dur);
1320 txSpeeds_.emplace_back(txSpeed);
1321 rxSpeeds_.emplace_back(rxSpeed);
1322 netTypes_.emplace_back(netType);
1323 packetIn_.emplace_back(packetIn);
1324 packetInSec_.emplace_back(packetInSec);
1325 packetOut_.emplace_back(packetOut);
1326 packetOutSec_.emplace_back(packetOutSec);
1327
1328 return Size() - 1;
1329 }
Durs() const1330 const std::deque<uint64_t>& NetDetailData::Durs() const
1331 {
1332 return durs_;
1333 }
RxSpeed() const1334 const std::deque<double>& NetDetailData::RxSpeed() const
1335 {
1336 return rxSpeeds_;
1337 }
TxSpeed() const1338 const std::deque<double>& NetDetailData::TxSpeed() const
1339 {
1340 return txSpeeds_;
1341 }
NetTypes() const1342 const std::deque<std::string>& NetDetailData::NetTypes() const
1343 {
1344 return netTypes_;
1345 }
RxDatas() const1346 const std::deque<uint64_t>& NetDetailData::RxDatas() const
1347 {
1348 return rxs_;
1349 }
TxDatas() const1350 const std::deque<uint64_t>& NetDetailData::TxDatas() const
1351 {
1352 return txs_;
1353 }
PacketIn() const1354 const std::deque<uint64_t>& NetDetailData::PacketIn() const
1355 {
1356 return packetIn_;
1357 }
PacketInSec() const1358 const std::deque<double>& NetDetailData::PacketInSec() const
1359 {
1360 return packetInSec_;
1361 }
PacketOut() const1362 const std::deque<uint64_t>& NetDetailData::PacketOut() const
1363 {
1364 return packetOut_;
1365 }
PacketOutSec() const1366 const std::deque<double>& NetDetailData::PacketOutSec() const
1367 {
1368 return packetOutSec_;
1369 }
1370
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)1371 void DiskIOData::AppendNewData(uint64_t ts,
1372 uint64_t dur,
1373 uint64_t rd,
1374 uint64_t wr,
1375 uint64_t rdPerSec,
1376 uint64_t wrPerSec,
1377 double rdCountPerSec,
1378 double wrCountPerSec,
1379 uint64_t rdCount,
1380 uint64_t wrCount)
1381 {
1382 timeStamps_.emplace_back(ts);
1383 durs_.emplace_back(dur);
1384 rdDatas_.emplace_back(rd);
1385 wrDatas_.emplace_back(wr);
1386 rdPerSec_.emplace_back(rdPerSec);
1387 wrPerSec_.emplace_back(wrPerSec);
1388 rdCountPerSec_.emplace_back(rdCountPerSec);
1389 wrCountPerSec_.emplace_back(wrCountPerSec);
1390 rdCountDatas_.emplace_back(rdCount);
1391 wrCountDatas_.emplace_back(wrCount);
1392 }
Durs() const1393 const std::deque<uint64_t>& DiskIOData::Durs() const
1394 {
1395 return durs_;
1396 }
RdDatas() const1397 const std::deque<uint64_t>& DiskIOData::RdDatas() const
1398 {
1399 return rdDatas_;
1400 }
WrDatas() const1401 const std::deque<uint64_t>& DiskIOData::WrDatas() const
1402 {
1403 return wrDatas_;
1404 }
RdSpeedDatas() const1405 const std::deque<double>& DiskIOData::RdSpeedDatas() const
1406 {
1407 return rdPerSec_;
1408 }
WrSpeedDatas() const1409 const std::deque<double>& DiskIOData::WrSpeedDatas() const
1410 {
1411 return wrPerSec_;
1412 }
1413
RdCountPerSecDatas() const1414 const std::deque<double>& DiskIOData::RdCountPerSecDatas() const
1415 {
1416 return rdCountPerSec_;
1417 }
WrCountPerSecDatas() const1418 const std::deque<double>& DiskIOData::WrCountPerSecDatas() const
1419 {
1420 return wrCountPerSec_;
1421 }
RdCountDatas() const1422 const std::deque<uint64_t>& DiskIOData::RdCountDatas() const
1423 {
1424 return rdCountDatas_;
1425 }
WrCountDatas() const1426 const std::deque<uint64_t>& DiskIOData::WrCountDatas() const
1427 {
1428 return wrCountDatas_;
1429 }
1430
AppendNewData(uint32_t callChainId,uint16_t type,uint32_t ipid,uint32_t itid,uint64_t startTs,uint64_t endTs,uint64_t dur,DataIndex returnValue,DataIndex errorCode,size_t size,int32_t fd,DataIndex fileId,DataIndex firstArgument,DataIndex secondArgument,DataIndex thirdArgument,DataIndex fourthArgument)1431 size_t FileSystemSample::AppendNewData(uint32_t callChainId,
1432 uint16_t type,
1433 uint32_t ipid,
1434 uint32_t itid,
1435 uint64_t startTs,
1436 uint64_t endTs,
1437 uint64_t dur,
1438 DataIndex returnValue,
1439 DataIndex errorCode,
1440 size_t size,
1441 int32_t fd,
1442 DataIndex fileId,
1443 DataIndex firstArgument,
1444 DataIndex secondArgument,
1445 DataIndex thirdArgument,
1446 DataIndex fourthArgument)
1447 {
1448 callChainIds_.emplace_back(callChainId);
1449 types_.emplace_back(type);
1450 ipids_.emplace_back(ipid);
1451 itids_.emplace_back(itid);
1452 startTs_.emplace_back(startTs);
1453 endTs_.emplace_back(endTs);
1454 durs_.emplace_back(dur);
1455 returnValues_.emplace_back(returnValue);
1456 errorCodes_.emplace_back(errorCode);
1457 fds_.emplace_back(fd);
1458 fileIds_.emplace_back(fileId);
1459 Sizes_.emplace_back(size);
1460 firstArguments_.emplace_back(firstArgument);
1461 secondArguments_.emplace_back(secondArgument);
1462 thirdArguments_.emplace_back(thirdArgument);
1463 fourthArguments_.emplace_back(fourthArgument);
1464 ids_.emplace_back(Size());
1465 return Size() - 1;
1466 }
CallChainIds() const1467 const std::deque<uint32_t>& FileSystemSample::CallChainIds() const
1468 {
1469 return callChainIds_;
1470 }
Types() const1471 const std::deque<uint16_t>& FileSystemSample::Types() const
1472 {
1473 return types_;
1474 }
Ipids() const1475 const std::deque<uint32_t>& FileSystemSample::Ipids() const
1476 {
1477 return ipids_;
1478 }
Itids() const1479 const std::deque<uint32_t>& FileSystemSample::Itids() const
1480 {
1481 return itids_;
1482 }
StartTs() const1483 const std::deque<uint64_t>& FileSystemSample::StartTs() const
1484 {
1485 return startTs_;
1486 }
EndTs() const1487 const std::deque<uint64_t>& FileSystemSample::EndTs() const
1488 {
1489 return endTs_;
1490 }
Durs() const1491 const std::deque<uint64_t>& FileSystemSample::Durs() const
1492 {
1493 return durs_;
1494 }
ReturnValues() const1495 const std::deque<DataIndex>& FileSystemSample::ReturnValues() const
1496 {
1497 return returnValues_;
1498 }
ErrorCodes() const1499 const std::deque<DataIndex>& FileSystemSample::ErrorCodes() const
1500 {
1501 return errorCodes_;
1502 }
Fds() const1503 const std::deque<int32_t>& FileSystemSample::Fds() const
1504 {
1505 return fds_;
1506 }
FileIds() const1507 const std::deque<DataIndex>& FileSystemSample::FileIds() const
1508 {
1509 return fileIds_;
1510 }
Sizes() const1511 const std::deque<size_t>& FileSystemSample::Sizes() const
1512 {
1513 return Sizes_;
1514 }
FirstArguments() const1515 const std::deque<DataIndex>& FileSystemSample::FirstArguments() const
1516 {
1517 return firstArguments_;
1518 }
SecondArguments() const1519 const std::deque<DataIndex>& FileSystemSample::SecondArguments() const
1520 {
1521 return secondArguments_;
1522 }
ThirdArguments() const1523 const std::deque<DataIndex>& FileSystemSample::ThirdArguments() const
1524 {
1525 return thirdArguments_;
1526 }
FourthArguments() const1527 const std::deque<DataIndex>& FileSystemSample::FourthArguments() const
1528 {
1529 return fourthArguments_;
1530 }
1531
AppendNewData(uint32_t callChainId,uint16_t type,uint32_t ipid,uint64_t startTs,uint64_t endTs,uint64_t dur,size_t size,DataIndex addr,uint32_t itid)1532 size_t PagedMemorySampleData::AppendNewData(uint32_t callChainId,
1533 uint16_t type,
1534 uint32_t ipid,
1535 uint64_t startTs,
1536 uint64_t endTs,
1537 uint64_t dur,
1538 size_t size,
1539 DataIndex addr,
1540 uint32_t itid)
1541 {
1542 callChainIds_.emplace_back(callChainId);
1543 types_.emplace_back(type);
1544 ipids_.emplace_back(ipid);
1545 startTs_.emplace_back(startTs);
1546 endTs_.emplace_back(endTs);
1547 durs_.emplace_back(dur);
1548 Sizes_.emplace_back(size);
1549 addrs_.emplace_back(addr);
1550 itids_.emplace_back(itid);
1551 ids_.emplace_back(Size());
1552 return Size() - 1;
1553 }
CallChainIds() const1554 const std::deque<uint32_t>& PagedMemorySampleData::CallChainIds() const
1555 {
1556 return callChainIds_;
1557 }
Types() const1558 const std::deque<uint16_t>& PagedMemorySampleData::Types() const
1559 {
1560 return types_;
1561 }
Ipids() const1562 const std::deque<uint32_t>& PagedMemorySampleData::Ipids() const
1563 {
1564 return ipids_;
1565 }
Itids() const1566 const std::deque<uint32_t>& PagedMemorySampleData::Itids() const
1567 {
1568 return itids_;
1569 }
StartTs() const1570 const std::deque<uint64_t>& PagedMemorySampleData::StartTs() const
1571 {
1572 return startTs_;
1573 }
EndTs() const1574 const std::deque<uint64_t>& PagedMemorySampleData::EndTs() const
1575 {
1576 return endTs_;
1577 }
Durs() const1578 const std::deque<uint64_t>& PagedMemorySampleData::Durs() const
1579 {
1580 return durs_;
1581 }
Sizes() const1582 const std::deque<size_t>& PagedMemorySampleData::Sizes() const
1583 {
1584 return Sizes_;
1585 }
Addr() const1586 const std::deque<DataIndex>& PagedMemorySampleData::Addr() const
1587 {
1588 return addrs_;
1589 }
1590
AppendNewData(uint32_t callChainId,uint32_t depth,DataIndex ip,DataIndex symbolId,DataIndex filePathId)1591 size_t EbpfCallStackData::AppendNewData(uint32_t callChainId,
1592 uint32_t depth,
1593 DataIndex ip,
1594 DataIndex symbolId,
1595 DataIndex filePathId)
1596 {
1597 callChainIds_.emplace_back(callChainId);
1598 depths_.emplace_back(depth);
1599 ips_.emplace_back(ip);
1600 symbolIds_.emplace_back(symbolId);
1601 filePathIds_.emplace_back(filePathId);
1602 ids_.emplace_back(Size());
1603 return Size() - 1;
1604 }
UpdateSymbolAndFilePathIndex(size_t row,DataIndex symbolId,DataIndex filePathId)1605 void EbpfCallStackData::UpdateSymbolAndFilePathIndex(size_t row, DataIndex symbolId, DataIndex filePathId)
1606 {
1607 if (row >= Size()) {
1608 TS_LOGE("The updated row does not exist!");
1609 return;
1610 }
1611 symbolIds_[row] = symbolId;
1612 filePathIds_[row] = filePathId;
1613 }
CallChainIds() const1614 const std::deque<uint32_t>& EbpfCallStackData::CallChainIds() const
1615 {
1616 return callChainIds_;
1617 }
Depths() const1618 const std::deque<uint32_t>& EbpfCallStackData::Depths() const
1619 {
1620 return depths_;
1621 }
Ips() const1622 const std::deque<DataIndex>& EbpfCallStackData::Ips() const
1623 {
1624 return ips_;
1625 }
SymbolIds() const1626 const std::deque<DataIndex>& EbpfCallStackData::SymbolIds() const
1627 {
1628 return symbolIds_;
1629 }
FilePathIds() const1630 const std::deque<DataIndex>& EbpfCallStackData::FilePathIds() const
1631 {
1632 return filePathIds_;
1633 }
1634 #if WITH_EBPF_HELP
AppendNewData(uint64_t start,uint64_t end,uint32_t offset,uint32_t pid,uint32_t fileNameLen,uint64_t fileNameIndex)1635 size_t EbpfProcessMaps::AppendNewData(uint64_t start,
1636 uint64_t end,
1637 uint32_t offset,
1638 uint32_t pid,
1639 uint32_t fileNameLen,
1640 uint64_t fileNameIndex)
1641 {
1642 starts_.emplace_back(start);
1643 ends_.emplace_back(end);
1644 offsets_.emplace_back(offset);
1645 pids_.emplace_back(pid);
1646 fileNameLens_.emplace_back(fileNameLen);
1647 fileNameIndexs_.emplace_back(fileNameIndex);
1648 ids_.emplace_back(Size());
1649 return Size() - 1;
1650 }
1651
Starts() const1652 const std::deque<uint64_t>& EbpfProcessMaps::Starts() const
1653 {
1654 return starts_;
1655 }
Ends() const1656 const std::deque<uint64_t>& EbpfProcessMaps::Ends() const
1657 {
1658 return ends_;
1659 }
Offsets() const1660 const std::deque<uint32_t>& EbpfProcessMaps::Offsets() const
1661 {
1662 return offsets_;
1663 }
Pids() const1664 const std::deque<uint32_t>& EbpfProcessMaps::Pids() const
1665 {
1666 return pids_;
1667 }
FileNameLens() const1668 const std::deque<uint32_t>& EbpfProcessMaps::FileNameLens() const
1669 {
1670 return fileNameLens_;
1671 }
FileNameIndexs() const1672 const std::deque<uint64_t>& EbpfProcessMaps::FileNameIndexs() const
1673 {
1674 return fileNameIndexs_;
1675 }
1676
AppendNewData(uint64_t elfId,uint64_t textVaddr,uint32_t textOffset,uint32_t strTabLen,uint32_t symTabLen,uint32_t fileNameLen,uint32_t symEntLen,uint64_t fileNameIndex)1677 size_t EbpfElf::AppendNewData(uint64_t elfId,
1678 uint64_t textVaddr,
1679 uint32_t textOffset,
1680 uint32_t strTabLen,
1681 uint32_t symTabLen,
1682 uint32_t fileNameLen,
1683 uint32_t symEntLen,
1684 uint64_t fileNameIndex)
1685 {
1686 elfIds_.emplace_back(elfId);
1687 textVaddrs_.emplace_back(textVaddr);
1688 textOffsets_.emplace_back(textOffset);
1689 strTabLens_.emplace_back(strTabLen);
1690 symTabLens_.emplace_back(symTabLen);
1691 fileNameLens_.emplace_back(fileNameLen);
1692 symEntLens_.emplace_back(symEntLen);
1693 fileNameIndexs_.emplace_back(fileNameIndex);
1694 ids_.emplace_back(Size());
1695 return Size() - 1;
1696 }
ElfIds() const1697 const std::deque<uint64_t>& EbpfElf::ElfIds() const
1698 {
1699 return elfIds_;
1700 }
TextVaddrs() const1701 const std::deque<uint64_t>& EbpfElf::TextVaddrs() const
1702 {
1703 return textVaddrs_;
1704 }
TextOffsets() const1705 const std::deque<uint32_t>& EbpfElf::TextOffsets() const
1706 {
1707 return textOffsets_;
1708 }
StrTabLens() const1709 const std::deque<uint32_t>& EbpfElf::StrTabLens() const
1710 {
1711 return strTabLens_;
1712 }
SymTabLens() const1713 const std::deque<uint32_t>& EbpfElf::SymTabLens() const
1714 {
1715 return symTabLens_;
1716 }
FileNameLens() const1717 const std::deque<uint32_t>& EbpfElf::FileNameLens() const
1718 {
1719 return fileNameLens_;
1720 }
SymEntLens() const1721 const std::deque<uint32_t>& EbpfElf::SymEntLens() const
1722 {
1723 return symEntLens_;
1724 }
FileNameIndexs() const1725 const std::deque<uint64_t>& EbpfElf::FileNameIndexs() const
1726 {
1727 return fileNameIndexs_;
1728 }
1729
AppendNewData(uint64_t elfId,uint32_t stName,uint64_t stValue,uint64_t stSize)1730 size_t EbpfElfSymbol::AppendNewData(uint64_t elfId, uint32_t stName, uint64_t stValue, uint64_t stSize)
1731 {
1732 elfIds_.emplace_back(elfId);
1733 stNames_.emplace_back(stName);
1734 stValues_.emplace_back(stValue);
1735 stSizes_.emplace_back(stSize);
1736 ids_.emplace_back(Size());
1737 return Size() - 1;
1738 }
ElfIds() const1739 const std::deque<uint64_t>& EbpfElfSymbol::ElfIds() const
1740 {
1741 return elfIds_;
1742 }
StNames() const1743 const std::deque<uint32_t>& EbpfElfSymbol::StNames() const
1744 {
1745 return stNames_;
1746 }
StValues() const1747 const std::deque<uint64_t>& EbpfElfSymbol::StValues() const
1748 {
1749 return stValues_;
1750 }
StSizes() const1751 const std::deque<uint64_t>& EbpfElfSymbol::StSizes() const
1752 {
1753 return stSizes_;
1754 }
1755 #endif
AppendAppName(uint8_t flags,DataIndex eventSource,DataIndex appName)1756 uint32_t AppNames::AppendAppName(uint8_t flags, DataIndex eventSource, DataIndex appName)
1757 {
1758 flags_.push_back(flags);
1759 appNames_.push_back(eventSource);
1760 keyNames_.push_back(appName);
1761 ids_.push_back(keyNames_.size() - 1);
1762 return Size() - 1;
1763 }
Falgs() const1764 const std::deque<uint8_t>& AppNames::Falgs() const
1765 {
1766 return flags_;
1767 }
EventSourceId() const1768 const std::deque<DataIndex>& AppNames::EventSourceId() const
1769 {
1770 return appNames_;
1771 }
AppName() const1772 const std::deque<DataIndex>& AppNames::AppName() const
1773 {
1774 return keyNames_;
1775 }
1776
AppendData(uint64_t serial,uint64_t ts,uint32_t nameId,uint32_t keyId,int32_t type,double numericValue,DataIndex stringValue)1777 void SysEventMeasureData::AppendData(uint64_t serial,
1778 uint64_t ts,
1779 uint32_t nameId,
1780 uint32_t keyId,
1781 int32_t type,
1782 double numericValue,
1783 DataIndex stringValue)
1784 {
1785 serial_.emplace_back(serial);
1786 ts_.emplace_back(ts);
1787 nameFilterIds_.emplace_back(nameId);
1788 appKeyFilterIds_.emplace_back(keyId);
1789 types_.emplace_back(type);
1790 numValues_.emplace_back(numericValue);
1791 stringValues_.emplace_back(stringValue);
1792 ids_.push_back(rowCount_);
1793 rowCount_++;
1794 }
Serial() const1795 const std::deque<uint64_t>& SysEventMeasureData::Serial() const
1796 {
1797 return serial_;
1798 }
Ts() const1799 const std::deque<uint64_t>& SysEventMeasureData::Ts() const
1800 {
1801 return ts_;
1802 }
NameFilterId() const1803 const std::deque<uint32_t>& SysEventMeasureData::NameFilterId() const
1804 {
1805 return nameFilterIds_;
1806 }
AppKeyFilterId() const1807 const std::deque<uint32_t>& SysEventMeasureData::AppKeyFilterId() const
1808 {
1809 return appKeyFilterIds_;
1810 }
Type() const1811 const std::deque<int32_t>& SysEventMeasureData::Type() const
1812 {
1813 return types_;
1814 }
NumValue() const1815 const std::deque<double>& SysEventMeasureData::NumValue() const
1816 {
1817 return numValues_;
1818 }
StringValue() const1819 const std::deque<DataIndex>& SysEventMeasureData::StringValue() const
1820 {
1821 return stringValues_;
1822 }
AppendNewData(int32_t brightness,int32_t btState,int32_t location,int32_t wifi,int32_t streamDefault,int32_t voiceCall,int32_t music,int32_t streamRing,int32_t media,int32_t voiceAssistant,int32_t system,int32_t alarm,int32_t notification,int32_t btSco,int32_t enforcedAudible,int32_t streamDtmf,int32_t streamTts,int32_t accessibility,int32_t recording,int32_t streamAll)1823 void DeviceStateData::AppendNewData(int32_t brightness,
1824 int32_t btState,
1825 int32_t location,
1826 int32_t wifi,
1827 int32_t streamDefault,
1828 int32_t voiceCall,
1829 int32_t music,
1830 int32_t streamRing,
1831 int32_t media,
1832 int32_t voiceAssistant,
1833 int32_t system,
1834 int32_t alarm,
1835 int32_t notification,
1836 int32_t btSco,
1837 int32_t enforcedAudible,
1838 int32_t streamDtmf,
1839 int32_t streamTts,
1840 int32_t accessibility,
1841 int32_t recording,
1842 int32_t streamAll)
1843 {
1844 brightness_.emplace_back(brightness);
1845 btStates_.emplace_back(btState);
1846 locations_.emplace_back(location);
1847 wifis_.emplace_back(wifi);
1848 streamDefaults_.emplace_back(streamDefault);
1849 voiceCalls_.emplace_back(voiceCall);
1850 musics_.emplace_back(music);
1851 streamRings_.emplace_back(streamRing);
1852 medias_.emplace_back(media);
1853 voiceAssistants_.emplace_back(voiceAssistant);
1854 systems_.emplace_back(system);
1855 alarms_.emplace_back(alarm);
1856 notifications_.emplace_back(notification);
1857 btScos_.emplace_back(btSco);
1858 enforcedAudibles_.emplace_back(enforcedAudible);
1859 streamDtmfs_.emplace_back(streamDtmf);
1860 streamTts_.emplace_back(streamTts);
1861 accessibilitys_.emplace_back(accessibility);
1862 recordings_.emplace_back(recording);
1863 streamAlls_.emplace_back(streamAll);
1864 ids_.push_back(rowCounts_);
1865 rowCounts_++;
1866 }
Brightness() const1867 const std::deque<int32_t>& DeviceStateData::Brightness() const
1868 {
1869 return brightness_;
1870 }
BtState() const1871 const std::deque<int32_t>& DeviceStateData::BtState() const
1872 {
1873 return btStates_;
1874 }
Location() const1875 const std::deque<int32_t>& DeviceStateData::Location() const
1876 {
1877 return locations_;
1878 }
Wifi() const1879 const std::deque<int32_t>& DeviceStateData::Wifi() const
1880 {
1881 return wifis_;
1882 }
StreamDefault() const1883 const std::deque<int32_t>& DeviceStateData::StreamDefault() const
1884 {
1885 return streamDefaults_;
1886 }
VoiceCall() const1887 const std::deque<int32_t>& DeviceStateData::VoiceCall() const
1888 {
1889 return voiceCalls_;
1890 }
Music() const1891 const std::deque<int32_t>& DeviceStateData::Music() const
1892 {
1893 return musics_;
1894 }
StreamRing() const1895 const std::deque<int32_t>& DeviceStateData::StreamRing() const
1896 {
1897 return streamRings_;
1898 }
Media() const1899 const std::deque<int32_t>& DeviceStateData::Media() const
1900 {
1901 return medias_;
1902 }
VoiceAssistant() const1903 const std::deque<int32_t>& DeviceStateData::VoiceAssistant() const
1904 {
1905 return voiceAssistants_;
1906 }
System() const1907 const std::deque<int32_t>& DeviceStateData::System() const
1908 {
1909 return systems_;
1910 }
Alarm() const1911