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 namespace SysTuning {
21 namespace TraceStdtype {
22 const int32_t MAX_SIZE_LEN = 80;
23 const int32_t ONE_MILLION_NANOSECONDS = 1000000;
24 #define UNUSED(expr) \
25 do { \
26 static_cast<void>(expr); \
27 } while (0)
SetDur(uint64_t index,uint64_t dur)28 void CpuCacheBase::SetDur(uint64_t index, uint64_t dur)
29 {
30 durs_[index] = dur;
31 }
AppendThreadState(InternalTime ts,InternalTime dur,InternalCpu cpu,InternalTid itid,TableRowId idState)32 TableRowId ThreadStateData::AppendThreadState(InternalTime ts,
33 InternalTime dur,
34 InternalCpu cpu,
35 InternalTid itid,
36 TableRowId idState)
37 {
38 timeStamps_.emplace_back(ts);
39 durations_.emplace_back(dur);
40 itids_.emplace_back(itid);
41 tids_.emplace_back(INVALID_UINT32);
42 pids_.emplace_back(INVALID_UINT32);
43 states_.emplace_back(idState);
44 cpus_.emplace_back(cpu);
45 argSetIds_.emplace_back(INVALID_UINT32);
46 return itids_.size() - 1;
47 }
48
SetDuration(TableRowId index,InternalTime dur)49 void ThreadStateData::SetDuration(TableRowId index, InternalTime dur)
50 {
51 durations_[index] = dur;
52 }
Finish()53 void DataDict::Finish()
54 {
55 std::string::size_type pos(0);
56 for (auto i = 0; i < dataDict_.size(); i++) {
57 if (dataDict_[i].empty()) {
58 continue;
59 }
60 while ((pos = dataDict_[i].find("\"")) != std::string::npos) {
61 dataDict_[i].replace(pos, 1, "\'");
62 }
63 while ((dataDict_[i].back() >= SPASCII_START && dataDict_[i].back() <= SPASCII_END) ||
64 dataDict_[i].back() == '\r') {
65 dataDict_[i].pop_back();
66 }
67 }
68 }
UpdateDuration(TableRowId index,InternalTime ts)69 TableRowId ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts)
70 {
71 if (durations_[index] == INVALID_TIME) {
72 durations_[index] = ts - timeStamps_[index];
73 }
74 return itids_[index];
75 }
76
End(TableRowId index,InternalTime ts)77 bool ThreadStateData::End(TableRowId index, InternalTime ts)
78 {
79 if (durations_[index] == INVALID_TIME) {
80 durations_[index] = -1;
81 return false;
82 }
83 return true;
84 }
UpdateState(TableRowId index,TableRowId idState)85 void ThreadStateData::UpdateState(TableRowId index, TableRowId idState)
86 {
87 states_[index] = idState;
88 }
SetArgSetId(TableRowId index,uint32_t setId)89 void ThreadStateData::SetArgSetId(TableRowId index, uint32_t setId)
90 {
91 argSetIds_[index] = setId;
92 }
93
UpdateDuration(TableRowId index,InternalTime ts,TableRowId idState)94 void ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts, TableRowId idState)
95 {
96 durations_[index] = ts - timeStamps_[index];
97 states_[index] = idState;
98 }
99
UpdateTidAndPid(TableRowId index,InternalTid tid,InternalTid pid)100 void ThreadStateData::UpdateTidAndPid(TableRowId index, InternalTid tid, InternalTid pid)
101 {
102 tids_[index] = tid;
103 pids_[index] = pid;
104 }
105
UpdateDuration(TableRowId index,InternalTime ts,InternalCpu cpu,TableRowId idState)106 TableRowId ThreadStateData::UpdateDuration(TableRowId index, InternalTime ts, InternalCpu cpu, TableRowId idState)
107 {
108 cpus_[index] = cpu;
109 durations_[index] = ts - timeStamps_[index];
110 states_[index] = idState;
111 return itids_[index];
112 }
113
AppendSchedSlice(uint64_t ts,uint64_t dur,uint64_t cpu,uint32_t internalTid,uint64_t endState,uint64_t priority)114 size_t SchedSlice::AppendSchedSlice(uint64_t ts,
115 uint64_t dur,
116 uint64_t cpu,
117 uint32_t internalTid,
118 uint64_t endState,
119 uint64_t priority)
120 {
121 timeStamps_.emplace_back(ts);
122 durs_.emplace_back(dur);
123 cpus_.emplace_back(cpu);
124 tsEnds_.emplace_back(0);
125 internalTids_.emplace_back(internalTid);
126 endStates_.emplace_back(endState);
127 priority_.emplace_back(priority);
128 argSets_.emplace_back(INVALID_UINT32);
129 return Size() - 1;
130 }
131
SetDuration(size_t index,uint64_t duration)132 void SchedSlice::SetDuration(size_t index, uint64_t duration)
133 {
134 durs_[index] = duration;
135 tsEnds_[index] = timeStamps_[index] + duration;
136 }
137
Update(uint64_t index,uint64_t ts,uint64_t state)138 void SchedSlice::Update(uint64_t index, uint64_t ts, uint64_t state)
139 {
140 durs_[index] = ts - timeStamps_[index];
141 endStates_[index] = state;
142 }
143
UpdateArg(uint64_t index,uint32_t argsetId)144 void SchedSlice::UpdateArg(uint64_t index, uint32_t argsetId)
145 {
146 argSets_[index] = argsetId;
147 }
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)148 size_t CallStack::AppendInternalAsyncSlice(uint64_t startT,
149 uint64_t durationNs,
150 InternalTid internalTid,
151 DataIndex cat,
152 uint16_t nameIdentify,
153 DataIndex name,
154 uint8_t depth,
155 uint64_t cookid,
156 const std::optional<uint64_t>& parentId)
157 {
158 AppendCommonInfo(startT, durationNs, internalTid);
159 AppendCallStack(cat, name, depth, parentId);
160 AppendDistributeInfo();
161 cookies_.emplace_back(cookid);
162 ids_.emplace_back(ids_.size());
163 identifys_.emplace_back(nameIdentify + depth);
164 return Size() - 1;
165 }
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)166 size_t CallStack::AppendInternalSlice(uint64_t startT,
167 uint64_t durationNs,
168 InternalTid internalTid,
169 DataIndex cat,
170 uint16_t nameIdentify,
171 DataIndex name,
172 uint8_t depth,
173 const std::optional<uint64_t>& parentId)
174 {
175 AppendCommonInfo(startT, durationNs, internalTid);
176 AppendCallStack(cat, name, depth, parentId);
177 identifys_.emplace_back(nameIdentify + depth);
178 ids_.emplace_back(ids_.size());
179 cookies_.emplace_back(INVALID_UINT64);
180 AppendDistributeInfo();
181 return Size() - 1;
182 }
183
AppendCommonInfo(uint64_t startT,uint64_t durationNs,InternalTid internalTid)184 void CallStack::AppendCommonInfo(uint64_t startT, uint64_t durationNs, InternalTid internalTid)
185 {
186 timeStamps_.emplace_back(startT);
187 durs_.emplace_back(durationNs);
188 callIds_.emplace_back(internalTid);
189 }
AppendCallStack(DataIndex cat,DataIndex name,uint8_t depth,std::optional<uint64_t> parentId)190 void CallStack::AppendCallStack(DataIndex cat, DataIndex name, uint8_t depth, std::optional<uint64_t> parentId)
191 {
192 parentIds_.emplace_back(parentId);
193 cats_.emplace_back(cat);
194 names_.emplace_back(name);
195 depths_.emplace_back(depth);
196 }
SetDistributeInfo(size_t index,const std::string & chainId,const std::string & spanId,const std::string & parentSpanId,const std::string & flag,const std::string & args)197 void CallStack::SetDistributeInfo(size_t index,
198 const std::string& chainId,
199 const std::string& spanId,
200 const std::string& parentSpanId,
201 const std::string& flag,
202 const std::string& args)
203 {
204 chainIds_[index] = chainId;
205 spanIds_[index] = spanId;
206 parentSpanIds_[index] = parentSpanId;
207 flags_[index] = flag;
208 args_[index] = args;
209 argSet_[index] = INVALID_UINT32;
210 }
AppendDistributeInfo(const std::string & chainId,const std::string & spanId,const std::string & parentSpanId,const std::string & flag,const std::string & args)211 void CallStack::AppendDistributeInfo(const std::string& chainId,
212 const std::string& spanId,
213 const std::string& parentSpanId,
214 const std::string& flag,
215 const std::string& args)
216 {
217 chainIds_.emplace_back(chainId);
218 spanIds_.emplace_back(spanId);
219 parentSpanIds_.emplace_back(parentSpanId);
220 flags_.emplace_back(flag);
221 args_.emplace_back(args);
222 argSet_.emplace_back(INVALID_UINT32);
223 }
AppendDistributeInfo()224 void CallStack::AppendDistributeInfo()
225 {
226 chainIds_.emplace_back("");
227 spanIds_.emplace_back("");
228 parentSpanIds_.emplace_back("");
229 flags_.emplace_back("");
230 args_.emplace_back("");
231 argSet_.emplace_back(INVALID_UINT32);
232 }
SetDuration(size_t index,uint64_t timeStamp)233 void CallStack::SetDuration(size_t index, uint64_t timeStamp)
234 {
235 durs_[index] = timeStamp - timeStamps_[index];
236 }
SetDurationWithFlag(size_t index,uint64_t timeStamp)237 void CallStack::SetDurationWithFlag(size_t index, uint64_t timeStamp)
238 {
239 durs_[index] = timeStamp - timeStamps_[index];
240 flags_[index] = "1";
241 }
242
SetFlag(size_t index,uint8_t flag)243 void CallStack::SetFlag(size_t index, uint8_t flag)
244 {
245 flags_[index] = std::to_string(flag);
246 }
SetDurationEx(size_t index,uint32_t dur)247 void CallStack::SetDurationEx(size_t index, uint32_t dur)
248 {
249 durs_[index] = dur;
250 }
251
SetIrqDurAndArg(size_t index,uint64_t timeStamp,uint32_t argSetId)252 void CallStack::SetIrqDurAndArg(size_t index, uint64_t timeStamp, uint32_t argSetId)
253 {
254 SetDuration(index, timeStamp);
255 argSet_[index] = argSetId;
256 }
SetTimeStamp(size_t index,uint64_t timeStamp)257 void CallStack::SetTimeStamp(size_t index, uint64_t timeStamp)
258 {
259 timeStamps_[index] = timeStamp;
260 }
261
SetDepth(size_t index,uint8_t depth)262 void CallStack::SetDepth(size_t index, uint8_t depth)
263 {
264 depths_[index] = depth;
265 }
SetArgSetId(size_t index,uint32_t argSetId)266 void CallStack::SetArgSetId(size_t index, uint32_t argSetId)
267 {
268 argSet_[index] = argSetId;
269 }
ParentIdData() const270 const std::deque<std::optional<uint64_t>>& CallStack::ParentIdData() const
271 {
272 return parentIds_;
273 }
CatsData() const274 const std::deque<DataIndex>& CallStack::CatsData() const
275 {
276 return cats_;
277 }
IdentifysData() const278 const std::deque<uint16_t>& CallStack::IdentifysData() const
279 {
280 return identifys_;
281 }
NamesData() const282 const std::deque<DataIndex>& CallStack::NamesData() const
283 {
284 return names_;
285 }
Depths() const286 const std::deque<uint8_t>& CallStack::Depths() const
287 {
288 return depths_;
289 }
Cookies() const290 const std::deque<uint64_t>& CallStack::Cookies() const
291 {
292 return cookies_;
293 }
CallIds() const294 const std::deque<uint32_t>& CallStack::CallIds() const
295 {
296 return callIds_;
297 }
ChainIds() const298 const std::deque<std::string>& CallStack::ChainIds() const
299 {
300 return chainIds_;
301 }
SpanIds() const302 const std::deque<std::string>& CallStack::SpanIds() const
303 {
304 return spanIds_;
305 }
ParentSpanIds() const306 const std::deque<std::string>& CallStack::ParentSpanIds() const
307 {
308 return parentSpanIds_;
309 }
Flags() const310 const std::deque<std::string>& CallStack::Flags() const
311 {
312 return flags_;
313 }
ArgsData() const314 const std::deque<std::string>& CallStack::ArgsData() const
315 {
316 return args_;
317 }
ArgSetIdsData() const318 const std::deque<uint32_t>& CallStack::ArgSetIdsData() const
319 {
320 return argSet_;
321 }
322
AppendNewArg(DataIndex nameId,BaseDataType dataType,int64_t value,size_t argSet)323 size_t ArgSet::AppendNewArg(DataIndex nameId, BaseDataType dataType, int64_t value, size_t argSet)
324 {
325 dataTypes_.emplace_back(dataType);
326 argset_.emplace_back(argSet);
327 ids_.emplace_back(Size());
328 values_.emplace_back(value);
329 names_.emplace_back(nameId);
330 return Size() - 1;
331 }
DataTypes() const332 const std::deque<BaseDataType>& ArgSet::DataTypes() const
333 {
334 return dataTypes_;
335 }
ValuesData() const336 const std::deque<int64_t>& ArgSet::ValuesData() const
337 {
338 return values_;
339 }
ArgsData() const340 const std::deque<uint64_t>& ArgSet::ArgsData() const
341 {
342 return argset_;
343 }
NamesData() const344 const std::deque<DataIndex>& ArgSet::NamesData() const
345 {
346 return names_;
347 }
348
AppendNewFilter(uint64_t filterId,DataIndex type,DataIndex nameId)349 size_t SysMeasureFilter::AppendNewFilter(uint64_t filterId, DataIndex type, DataIndex nameId)
350 {
351 ids_.emplace_back(filterId);
352 names_.emplace_back(nameId);
353 types_.emplace_back(type);
354 return ids_.size() - 1;
355 }
NamesData() const356 const std::deque<DataIndex>& SysMeasureFilter::NamesData() const
357 {
358 return names_;
359 }
360
TypesData() const361 const std::deque<DataIndex>& SysMeasureFilter::TypesData() const
362 {
363 return types_;
364 }
AppendNewDataType(BaseDataType dataType,DataIndex dataDescIndex)365 size_t DataType::AppendNewDataType(BaseDataType dataType, DataIndex dataDescIndex)
366 {
367 ids_.emplace_back(Size());
368 dataTypes_.emplace_back(dataType);
369 descs_.emplace_back(dataDescIndex);
370 return Size() - 1;
371 }
372
DataTypes() const373 const std::deque<BaseDataType>& DataType::DataTypes() const
374 {
375 return dataTypes_;
376 }
DataDesc() const377 const std::deque<DataIndex>& DataType::DataDesc() const
378 {
379 return descs_;
380 }
AppendNewFilterData(std::string type,std::string name,uint64_t sourceArgSetId)381 size_t Filter::AppendNewFilterData(std::string type, std::string name, uint64_t sourceArgSetId)
382 {
383 nameDeque_.emplace_back(name);
384 sourceArgSetId_.emplace_back(sourceArgSetId);
385 ids_.emplace_back(Size());
386 typeDeque_.emplace_back(type);
387 return Size() - 1;
388 }
389
AppendMeasureData(uint32_t type,uint64_t timeStamp,int64_t value,uint32_t filterId)390 size_t Measure::AppendMeasureData(uint32_t type, uint64_t timeStamp, int64_t value, uint32_t filterId)
391 {
392 valuesDeque_.emplace_back(value);
393 filterIdDeque_.emplace_back(filterId);
394 typeDeque_.emplace_back(type);
395 timeStamps_.emplace_back(timeStamp);
396 durDeque_.emplace_back(INVALID_UINT64);
397 return Size() - 1;
398 }
399
SetDur(uint32_t row,uint64_t timeStamp)400 void Measure::SetDur(uint32_t row, uint64_t timeStamp)
401 {
402 durDeque_[row] = timeStamp - timeStamps_[row];
403 }
AppendRawData(uint32_t id,uint64_t timeStamp,uint32_t name,uint32_t cpu,uint32_t internalTid)404 size_t Raw::AppendRawData(uint32_t id, uint64_t timeStamp, uint32_t name, uint32_t cpu, uint32_t internalTid)
405 {
406 ids_.emplace_back(id);
407 timeStamps_.emplace_back(timeStamp);
408 nameDeque_.emplace_back(name);
409 cpuDeque_.emplace_back(cpu);
410 itidDeque_.emplace_back(internalTid);
411 return Size() - 1;
412 }
413
AppendNewFilter(uint64_t filterId,uint32_t nameIndex,uint64_t internalTid)414 size_t ThreadMeasureFilter::AppendNewFilter(uint64_t filterId, uint32_t nameIndex, uint64_t internalTid)
415 {
416 filterId_.emplace_back(filterId);
417 nameIndex_.emplace_back(nameIndex);
418 internalTids_.emplace_back(internalTid);
419 return Size() - 1;
420 }
421
AppendInstantEventData(uint64_t timeStamp,DataIndex nameIndex,int64_t internalTid,int64_t wakeupFromInternalPid)422 size_t Instants::AppendInstantEventData(uint64_t timeStamp,
423 DataIndex nameIndex,
424 int64_t internalTid,
425 int64_t wakeupFromInternalPid)
426 {
427 internalTids_.emplace_back(internalTid);
428 timeStamps_.emplace_back(timeStamp);
429 NameIndexs_.emplace_back(nameIndex);
430 wakeupFromInternalPids_.emplace_back(wakeupFromInternalPid);
431 return Size() - 1;
432 }
AppendNewLogInfo(uint64_t seq,uint64_t timeStamp,uint32_t pid,uint32_t tid,DataIndex level,DataIndex tag,DataIndex context,uint64_t originTs)433 size_t LogInfo::AppendNewLogInfo(uint64_t seq,
434 uint64_t timeStamp,
435 uint32_t pid,
436 uint32_t tid,
437 DataIndex level,
438 DataIndex tag,
439 DataIndex context,
440 uint64_t originTs)
441 {
442 hilogLineSeqs_.emplace_back(seq);
443 timeStamps_.emplace_back(timeStamp);
444 pids_.emplace_back(pid);
445 tids_.emplace_back(tid);
446 levels_.emplace_back(level);
447 tags_.emplace_back(tag);
448 contexts_.emplace_back(context);
449 originTs_.emplace_back(originTs);
450 return Size() - 1;
451 }
HilogLineSeqs() const452 const std::deque<uint64_t>& LogInfo::HilogLineSeqs() const
453 {
454 return hilogLineSeqs_;
455 }
Pids() const456 const std::deque<uint32_t>& LogInfo::Pids() const
457 {
458 return pids_;
459 }
Tids() const460 const std::deque<uint32_t>& LogInfo::Tids() const
461 {
462 return tids_;
463 }
Levels() const464 const std::deque<DataIndex>& LogInfo::Levels() const
465 {
466 return levels_;
467 }
Tags() const468 const std::deque<DataIndex>& LogInfo::Tags() const
469 {
470 return tags_;
471 }
Contexts() const472 const std::deque<DataIndex>& LogInfo::Contexts() const
473 {
474 return contexts_;
475 }
OriginTimeStamData() const476 const std::deque<uint64_t>& LogInfo::OriginTimeStamData() const
477 {
478 return originTs_;
479 }
UpdateCallChainId(size_t row,uint32_t callChainId)480 void NativeHook::UpdateCallChainId(size_t row, uint32_t callChainId)
481 {
482 if (row < Size()) {
483 callChainIds_[row] = callChainId;
484 } else {
485 TS_LOGE("Native hook update callChainId failed!!!");
486 }
487 }
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)488 size_t NativeHook::AppendNewNativeHookData(uint32_t callChainId,
489 uint32_t ipid,
490 uint32_t itid,
491 std::string eventType,
492 DataIndex subType,
493 uint64_t timeStamp,
494 uint64_t endTimeStamp,
495 uint64_t duration,
496 uint64_t addr,
497 int64_t memSize)
498 {
499 callChainIds_.emplace_back(callChainId);
500 ipids_.emplace_back(ipid);
501 itids_.emplace_back(itid);
502 eventTypes_.emplace_back(eventType);
503 subTypes_.emplace_back(subType);
504 timeStamps_.emplace_back(timeStamp);
505 endTimeStamps_.emplace_back(endTimeStamp);
506 durations_.emplace_back(duration);
507 addrs_.emplace_back(addr);
508 memSizes_.emplace_back(memSize);
509 if (eventType == ALLOC_EVET) {
510 countHeapSizes_ += memSize;
511 allMemSizes_.emplace_back(countHeapSizes_);
512 } else if (eventType == FREE_EVENT) {
513 countHeapSizes_ -= memSize;
514 allMemSizes_.emplace_back(countHeapSizes_);
515 } else if (eventType == MMAP_EVENT) {
516 countMmapSizes_ += memSize;
517 allMemSizes_.emplace_back(countMmapSizes_);
518 } else if (eventType == MUNMAP_EVENT) {
519 countMmapSizes_ -= memSize;
520 allMemSizes_.emplace_back(countMmapSizes_);
521 }
522 currentSizeDurs_.emplace_back(0);
523 lastCallerPathIndexs_.emplace_back(INVALID_UINT64);
524 return Size() - 1;
525 }
UpdateEndTimeStampAndDuration(size_t row,uint64_t endTimeStamp)526 void NativeHook::UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp)
527 {
528 endTimeStamps_[row] = endTimeStamp;
529 durations_[row] = endTimeStamp - timeStamps_[row];
530 }
UpdateCurrentSizeDur(size_t row,uint64_t timeStamp)531 void NativeHook::UpdateCurrentSizeDur(size_t row, uint64_t timeStamp)
532 {
533 currentSizeDurs_[row] = timeStamp - timeStamps_[row];
534 }
UpdateMemMapSubType(uint64_t row,uint64_t tagId)535 void NativeHook::UpdateMemMapSubType(uint64_t row, uint64_t tagId)
536 {
537 if (row < subTypes_.size()) {
538 subTypes_[row] = tagId;
539 } else {
540 TS_LOGE("subTypes_ row is invalid!");
541 }
542 }
UpdateLastCallerPathIndexs(std::unordered_map<uint32_t,uint64_t> & callIdToLasLibId)543 void NativeHook::UpdateLastCallerPathIndexs(std::unordered_map<uint32_t, uint64_t>& callIdToLasLibId)
544 {
545 if (callIdToLasLibId.empty()) {
546 return;
547 }
548 for (auto i = 0; i < Size(); ++i) {
549 auto symbolIt = callIdToLasLibId.find(callChainIds_[i]);
550 if (symbolIt != callIdToLasLibId.end()) {
551 lastCallerPathIndexs_[i] = symbolIt->second;
552 } else {
553 lastCallerPathIndexs_[i] = INVALID_UINT64;
554 }
555 }
556 }
CallChainIds() const557 const std::deque<uint32_t>& NativeHook::CallChainIds() const
558 {
559 return callChainIds_;
560 }
Ipids() const561 const std::deque<uint32_t>& NativeHook::Ipids() const
562 {
563 return ipids_;
564 }
Itids() const565 const std::deque<uint32_t>& NativeHook::Itids() const
566 {
567 return itids_;
568 }
EventTypes() const569 const std::deque<std::string>& NativeHook::EventTypes() const
570 {
571 return eventTypes_;
572 }
SubTypes() const573 const std::deque<DataIndex>& NativeHook::SubTypes() const
574 {
575 return subTypes_;
576 }
EndTimeStamps() const577 const std::deque<uint64_t>& NativeHook::EndTimeStamps() const
578 {
579 return endTimeStamps_;
580 }
Durations() const581 const std::deque<uint64_t>& NativeHook::Durations() const
582 {
583 return durations_;
584 }
Addrs() const585 const std::deque<uint64_t>& NativeHook::Addrs() const
586 {
587 return addrs_;
588 }
MemSizes() const589 const std::deque<int64_t>& NativeHook::MemSizes() const
590 {
591 return memSizes_;
592 }
AllMemSizes() const593 const std::deque<int64_t>& NativeHook::AllMemSizes() const
594 {
595 return allMemSizes_;
596 }
CurrentSizeDurs() const597 const std::deque<uint64_t>& NativeHook::CurrentSizeDurs() const
598 {
599 return currentSizeDurs_;
600 }
LastCallerPathIndexs() const601 const std::deque<uint64_t>& NativeHook::LastCallerPathIndexs() const
602 {
603 return lastCallerPathIndexs_;
604 }
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)605 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
606 uint64_t depth,
607 uint64_t ip,
608 uint64_t sp,
609 DataIndex symbolName,
610 DataIndex filePath,
611 uint64_t offset,
612 uint64_t symbolOffset,
613 const std::string& vaddr)
614 {
615 callChainIds_.emplace_back(callChainId);
616 ips_.emplace_back(ip);
617 sps_.emplace_back(sp);
618 depths_.emplace_back(depth);
619 symbolNames_.emplace_back(symbolName);
620 filePaths_.emplace_back(filePath);
621 offsets_.emplace_back(offset);
622 symbolOffsets_.emplace_back(symbolOffset);
623 vaddrs_.emplace_back(vaddr);
624 return Size() - 1;
625 }
AppendNewNativeHookFrame(uint32_t callChainId,uint64_t depth,uint64_t ip,uint64_t sp,DataIndex symbolName,DataIndex filePath,uint64_t offset,uint64_t symbolOffset)626 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
627 uint64_t depth,
628 uint64_t ip,
629 uint64_t sp,
630 DataIndex symbolName,
631 DataIndex filePath,
632 uint64_t offset,
633 uint64_t symbolOffset)
634 {
635 callChainIds_.emplace_back(callChainId);
636 ips_.emplace_back(ip);
637 sps_.emplace_back(sp);
638 depths_.emplace_back(depth);
639 symbolNames_.emplace_back(symbolName);
640 filePaths_.emplace_back(filePath);
641 offsets_.emplace_back(offset);
642 symbolOffsets_.emplace_back(symbolOffset);
643 return Size() - 1;
644 }
UpdateSymbolIdToNameMap(uint64_t originSymbolId,uint64_t symbolId)645 void NativeHookFrame::UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId)
646 {
647 symbolIdToSymbolName_.insert(std::make_pair(originSymbolId, symbolId));
648 }
UpdateFrameInfo(size_t row,DataIndex symbolIndex,DataIndex filePathIndex,uint64_t offset,uint64_t symbolOffset)649 void NativeHookFrame::UpdateFrameInfo(size_t row,
650 DataIndex symbolIndex,
651 DataIndex filePathIndex,
652 uint64_t offset,
653 uint64_t symbolOffset)
654 {
655 if (row >= Size()) {
656 TS_LOGE("The updated row does not exist!");
657 return;
658 }
659 symbolNames_[row] = symbolIndex;
660 filePaths_[row] = filePathIndex;
661 offsets_[row] = offset;
662 symbolOffsets_[row] = symbolOffset;
663 }
664
UpdateSymbolId()665 void NativeHookFrame::UpdateSymbolId()
666 {
667 if (symbolIdToSymbolName_.empty()) {
668 return;
669 }
670 for (auto i = 0; i < Size(); ++i) {
671 auto symbolIt = symbolIdToSymbolName_.find(symbolNames_[i]);
672 if (symbolIt != symbolIdToSymbolName_.end()) {
673 symbolNames_[i] = symbolIt->second;
674 }
675 }
676 }
UpdateSymbolId(size_t index,DataIndex symbolId)677 void NativeHookFrame::UpdateSymbolId(size_t index, DataIndex symbolId)
678 {
679 if (index < Size()) {
680 symbolNames_[index] = symbolId;
681 }
682 }
UpdateFileId(std::map<uint32_t,uint64_t> & filePathIdToFilePathName)683 void NativeHookFrame::UpdateFileId(std::map<uint32_t, uint64_t>& filePathIdToFilePathName)
684 {
685 if (filePathIdToFilePathName.empty()) {
686 return;
687 }
688 for (auto i = 0; i < Size(); ++i) {
689 auto symbolIt = filePathIdToFilePathName.find(filePaths_[i]);
690 if (symbolIt != filePathIdToFilePathName.end()) {
691 filePaths_[i] = symbolIt->second;
692 }
693 }
694 }
UpdateVaddrs(std::deque<std::string> & vaddrs)695 void NativeHookFrame::UpdateVaddrs(std::deque<std::string>& vaddrs)
696 {
697 vaddrs_.assign(vaddrs.begin(), vaddrs.end());
698 }
CallChainIds() const699 const std::deque<uint32_t>& NativeHookFrame::CallChainIds() const
700 {
701 return callChainIds_;
702 }
Depths() const703 const std::deque<uint64_t>& NativeHookFrame::Depths() const
704 {
705 return depths_;
706 }
Ips() const707 const std::deque<uint64_t>& NativeHookFrame::Ips() const
708 {
709 return ips_;
710 }
Sps() const711 const std::deque<uint64_t>& NativeHookFrame::Sps() const
712 {
713 return sps_;
714 }
SymbolNames() const715 const std::deque<DataIndex>& NativeHookFrame::SymbolNames() const
716 {
717 return symbolNames_;
718 }
FilePaths() const719 const std::deque<DataIndex>& NativeHookFrame::FilePaths() const
720 {
721 return filePaths_;
722 }
Offsets() const723 const std::deque<uint64_t>& NativeHookFrame::Offsets() const
724 {
725 return offsets_;
726 }
SymbolOffsets() const727 const std::deque<uint64_t>& NativeHookFrame::SymbolOffsets() const
728 {
729 return symbolOffsets_;
730 }
Vaddrs() const731 const std::deque<std::string>& NativeHookFrame::Vaddrs() const
732 {
733 return vaddrs_;
734 }
735
AppendNewNativeHookStatistic(uint32_t ipid,uint64_t timeStamp,uint32_t callChainId,uint32_t memoryType,uint64_t applyCount,uint64_t releaseCount,uint64_t applySize,uint64_t releaseSize)736 size_t NativeHookStatistic::AppendNewNativeHookStatistic(uint32_t ipid,
737 uint64_t timeStamp,
738 uint32_t callChainId,
739 uint32_t memoryType,
740 uint64_t applyCount,
741 uint64_t releaseCount,
742 uint64_t applySize,
743 uint64_t releaseSize)
744 {
745 ids_.emplace_back(Size());
746 ipids_.emplace_back(ipid);
747 timeStamps_.emplace_back(timeStamp);
748 callChainIds_.emplace_back(callChainId);
749 memoryTypes_.emplace_back(memoryType);
750 applyCounts_.emplace_back(applyCount);
751 releaseCounts_.emplace_back(releaseCount);
752 applySizes_.emplace_back(applySize);
753 releaseSizes_.emplace_back(releaseSize);
754 return Size() - 1;
755 }
Ipids() const756 const std::deque<uint32_t>& NativeHookStatistic::Ipids() const
757 {
758 return ipids_;
759 }
CallChainIds() const760 const std::deque<uint32_t>& NativeHookStatistic::CallChainIds() const
761 {
762 return callChainIds_;
763 }
MemoryTypes() const764 const std::deque<uint32_t>& NativeHookStatistic::MemoryTypes() const
765 {
766 return memoryTypes_;
767 }
ApplyCounts() const768 const std::deque<uint64_t>& NativeHookStatistic::ApplyCounts() const
769 {
770 return applyCounts_;
771 }
ReleaseCounts() const772 const std::deque<uint64_t>& NativeHookStatistic::ReleaseCounts() const
773 {
774 return releaseCounts_;
775 }
ApplySizes() const776 const std::deque<uint64_t>& NativeHookStatistic::ApplySizes() const
777 {
778 return applySizes_;
779 }
ReleaseSizes() const780 const std::deque<uint64_t>& NativeHookStatistic::ReleaseSizes() const
781 {
782 return releaseSizes_;
783 }
AppendNewHidumpInfo(uint64_t timeStamp,uint32_t fps)784 size_t Hidump::AppendNewHidumpInfo(uint64_t timeStamp, uint32_t fps)
785 {
786 timeStamps_.emplace_back(timeStamp);
787 fpss_.emplace_back(fps);
788 return Size() - 1;
789 }
Fpss() const790 const std::deque<uint32_t>& Hidump::Fpss() const
791 {
792 return fpss_;
793 }
794
AppendNewPerfCallChain(uint64_t sampleId,uint32_t callChainId,uint64_t vaddrInFile,uint64_t fileId,uint64_t symbolId)795 size_t PerfCallChain::AppendNewPerfCallChain(uint64_t sampleId,
796 uint32_t callChainId,
797 uint64_t vaddrInFile,
798 uint64_t fileId,
799 uint64_t symbolId)
800 {
801 ids_.emplace_back(Size());
802 sampleIds_.emplace_back(sampleId);
803 callChainIds_.emplace_back(callChainId);
804 vaddrInFiles_.emplace_back(vaddrInFile);
805 fileIds_.emplace_back(fileId);
806 symbolIds_.emplace_back(symbolId);
807 names_.emplace_back("");
808 return Size() - 1;
809 }
SampleIds() const810 const std::deque<uint64_t>& PerfCallChain::SampleIds() const
811 {
812 return sampleIds_;
813 }
CallChainIds() const814 const std::deque<uint32_t>& PerfCallChain::CallChainIds() const
815 {
816 return callChainIds_;
817 }
VaddrInFiles() const818 const std::deque<uint64_t>& PerfCallChain::VaddrInFiles() const
819 {
820 return vaddrInFiles_;
821 }
FileIds() const822 const std::deque<uint64_t>& PerfCallChain::FileIds() const
823 {
824 return fileIds_;
825 }
SymbolIds() const826 const std::deque<uint64_t>& PerfCallChain::SymbolIds() const
827 {
828 return symbolIds_;
829 }
830
Names() const831 const std::deque<std::string>& PerfCallChain::Names() const
832 {
833 return names_;
834 }
SetName(uint64_t index,const std::string & name)835 void PerfCallChain::SetName(uint64_t index, const std::string& name)
836 {
837 names_[index] = name;
838 }
Clear()839 void PerfCallChain::Clear()
840 {
841 CacheBase::Clear();
842 sampleIds_.clear();
843 callChainIds_.clear();
844 vaddrInFiles_.clear();
845 fileIds_.clear();
846 symbolIds_.clear();
847 names_.clear();
848 }
AppendNewPerfFiles(uint64_t fileIds,uint32_t serial,DataIndex symbols,DataIndex filePath)849 size_t PerfFiles::AppendNewPerfFiles(uint64_t fileIds, uint32_t serial, DataIndex symbols, DataIndex filePath)
850 {
851 ids_.emplace_back(Size());
852 fileIds_.emplace_back(fileIds);
853 serials_.emplace_back(serial);
854 symbols_.emplace_back(symbols);
855 filePaths_.emplace_back(filePath);
856 return Size() - 1;
857 }
FileIds() const858 const std::deque<uint64_t>& PerfFiles::FileIds() const
859 {
860 return fileIds_;
861 }
862
Serials() const863 const std::deque<uint32_t>& PerfFiles::Serials() const
864 {
865 return serials_;
866 }
Symbols() const867 const std::deque<DataIndex>& PerfFiles::Symbols() const
868 {
869 return symbols_;
870 }
FilePaths() const871 const std::deque<DataIndex>& PerfFiles::FilePaths() const
872 {
873 return filePaths_;
874 }
875
Clear()876 void PerfFiles::Clear()
877 {
878 CacheBase::Clear();
879 fileIds_.clear();
880 serials_.clear();
881 symbols_.clear();
882 filePaths_.clear();
883 }
884
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)885 size_t PerfSample::AppendNewPerfSample(uint32_t sampleId,
886 uint64_t timeStamp,
887 uint32_t tid,
888 uint64_t eventCount,
889 uint64_t eventTypeId,
890 uint64_t timestampTrace,
891 uint64_t cpuId,
892 uint64_t threadState)
893 {
894 ids_.emplace_back(Size());
895 sampleIds_.emplace_back(sampleId);
896 timeStamps_.emplace_back(timeStamp);
897 tids_.emplace_back(tid);
898 eventCounts_.emplace_back(eventCount);
899 eventTypeIds_.emplace_back(eventTypeId);
900 timestampTraces_.emplace_back(timestampTrace);
901 cpuIds_.emplace_back(cpuId);
902 threadStates_.emplace_back(threadState);
903 return Size() - 1;
904 }
SampleIds() const905 const std::deque<uint32_t>& PerfSample::SampleIds() const
906 {
907 return sampleIds_;
908 }
Tids() const909 const std::deque<uint32_t>& PerfSample::Tids() const
910 {
911 return tids_;
912 }
EventCounts() const913 const std::deque<uint64_t>& PerfSample::EventCounts() const
914 {
915 return eventCounts_;
916 }
EventTypeIds() const917 const std::deque<uint64_t>& PerfSample::EventTypeIds() const
918 {
919 return eventTypeIds_;
920 }
TimestampTraces() const921 const std::deque<uint64_t>& PerfSample::TimestampTraces() const
922 {
923 return timestampTraces_;
924 }
CpuIds() const925 const std::deque<uint64_t>& PerfSample::CpuIds() const
926 {
927 return cpuIds_;
928 }
ThreadStates() const929 const std::deque<DataIndex>& PerfSample::ThreadStates() const
930 {
931 return threadStates_;
932 }
933
Clear()934 void PerfSample::Clear()
935 {
936 CacheBase::Clear();
937 sampleIds_.clear();
938 tids_.clear();
939 eventCounts_.clear();
940 eventTypeIds_.clear();
941 timestampTraces_.clear();
942 cpuIds_.clear();
943 threadStates_.clear();
944 }
945
AppendNewPerfThread(uint32_t pid,uint32_t tid,DataIndex threadName)946 size_t PerfThread::AppendNewPerfThread(uint32_t pid, uint32_t tid, DataIndex threadName)
947 {
948 ids_.emplace_back(Size());
949 pids_.emplace_back(pid);
950 tids_.emplace_back(tid);
951 threadNames_.emplace_back(threadName);
952 return Size() - 1;
953 }
Pids() const954 const std::deque<uint32_t>& PerfThread::Pids() const
955 {
956 return pids_;
957 }
Tids() const958 const std::deque<uint32_t>& PerfThread::Tids() const
959 {
960 return tids_;
961 }
ThreadNames() const962 const std::deque<DataIndex>& PerfThread::ThreadNames() const
963 {
964 return threadNames_;
965 }
Clear()966 void PerfThread::Clear()
967 {
968 CacheBase::Clear();
969 tids_.clear();
970 pids_.clear();
971 threadNames_.clear();
972 }
AppendNewPerfReport(DataIndex type,DataIndex value)973 size_t PerfReport::AppendNewPerfReport(DataIndex type, DataIndex value)
974 {
975 ids_.emplace_back(Size());
976 types_.emplace_back(type);
977 values_.emplace_back(value);
978 return Size() - 1;
979 }
Types() const980 const std::deque<DataIndex>& PerfReport::Types() const
981 {
982 return types_;
983 }
Values() const984 const std::deque<DataIndex>& PerfReport::Values() const
985 {
986 return values_;
987 }
AppendNewFilter(uint64_t id,DataIndex name,uint32_t internalPid)988 size_t ProcessMeasureFilter::AppendNewFilter(uint64_t id, DataIndex name, uint32_t internalPid)
989 {
990 internalPids_.emplace_back(internalPid);
991 ids_.emplace_back(id);
992 names_.emplace_back(name);
993 return Size() - 1;
994 }
AppendNewFilter(uint64_t id,DataIndex type,DataIndex name,uint64_t cpu)995 size_t ClockEventData::AppendNewFilter(uint64_t id, DataIndex type, DataIndex name, uint64_t cpu)
996 {
997 cpus_.emplace_back(cpu);
998 ids_.emplace_back(id);
999 types_.emplace_back(type);
1000 names_.emplace_back(name);
1001 return Size() - 1;
1002 }
AppendNewFilter(uint64_t id,uint64_t rate,DataIndex name,uint64_t cpu)1003 size_t ClkEventData::AppendNewFilter(uint64_t id, uint64_t rate, DataIndex name, uint64_t cpu)
1004 {
1005 ids_.emplace_back(id);
1006 rates_.emplace_back(rate);
1007 names_.emplace_back(name);
1008 cpus_.emplace_back(cpu);
1009 return Size() - 1;
1010 }
AppendSysCallData(int64_t sysCallNum,DataIndex type,uint32_t ipid,uint64_t timeStamp,int64_t ret)1011 size_t SysCall::AppendSysCallData(int64_t sysCallNum, DataIndex type, uint32_t ipid, uint64_t timeStamp, int64_t ret)
1012 {
1013 sysCallNums_.emplace_back(sysCallNum);
1014 types_.emplace_back(type);
1015 ipids_.emplace_back(ipid);
1016 timeStamps_.emplace_back(timeStamp);
1017 rets_.emplace_back(ret);
1018 return Size() - 1;
1019 }
StatAndInfo()1020 StatAndInfo::StatAndInfo()
1021 {
1022 // sched_switch_received | sched_switch_not_match | sched_switch_not_not_supported etc.
1023 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1024 event_[i] = config_.eventNameMap_.at(static_cast<SupportedTraceEventType>(i));
1025 }
1026 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1027 stat_[j] = config_.eventErrorDescMap_.at(static_cast<StatType>(j));
1028 }
1029
1030 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1031 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1032 statSeverity_[i][j] = config_.eventParserStatSeverityDescMap_.at(static_cast<SupportedTraceEventType>(i))
1033 .at(static_cast<StatType>(j));
1034 }
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 statSeverityDesc_[i][j] = config_.serverityLevelDescMap_.at(statSeverity_[i][j]);
1040 }
1041 }
1042
1043 for (int32_t i = TRACE_EVENT_START; i < TRACE_EVENT_MAX; i++) {
1044 for (int32_t j = STAT_EVENT_START; j < STAT_EVENT_MAX; j++) {
1045 statCount_[i][j] = 0;
1046 }
1047 }
1048 clockid2ClockNameMap_ = {
1049 {TS_CLOCK_UNKNOW, "unknown"}, {TS_CLOCK_BOOTTIME, "boottime"},
1050 {TS_CLOCK_REALTIME, "realtime"}, {TS_CLOCK_REALTIME_COARSE, "realtime_corse"},
1051 {TS_MONOTONIC, "monotonic"}, {TS_MONOTONIC_COARSE, "monotonic-coarse"},
1052 {TS_MONOTONIC_RAW, "monotonic-raw"},
1053 };
1054 }
IncreaseStat(SupportedTraceEventType eventType,StatType type)1055 void StatAndInfo::IncreaseStat(SupportedTraceEventType eventType, StatType type)
1056 {
1057 statCount_[eventType][type]++;
1058 }
GetValue(SupportedTraceEventType eventType,StatType type) const1059 const uint32_t& StatAndInfo::GetValue(SupportedTraceEventType eventType, StatType type) const
1060 {
1061 return statCount_[eventType][type];
1062 }
GetEvent(SupportedTraceEventType eventType) const1063 const std::string& StatAndInfo::GetEvent(SupportedTraceEventType eventType) const
1064 {
1065 return event_[eventType];
1066 }
GetStat(StatType type) const1067 const std::string& StatAndInfo::GetStat(StatType type) const
1068 {
1069 return stat_[type];
1070 }
GetSeverityDesc(SupportedTraceEventType eventType,StatType type) const1071 const std::string& StatAndInfo::GetSeverityDesc(SupportedTraceEventType eventType, StatType type) const
1072 {
1073 return statSeverityDesc_[eventType][type];
1074 }
GetSeverity(SupportedTraceEventType eventType,StatType type) const1075 const StatSeverityLevel& StatAndInfo::GetSeverity(SupportedTraceEventType eventType, StatType type) const
1076 {
1077 return statSeverity_[eventType][type];
1078 }
1079
Size() const1080 uint64_t SymbolsData::Size() const
1081 {
1082 return addrs_.size();
1083 }
InsertSymbol(const DataIndex & name,const uint64_t & addr)1084 void SymbolsData::InsertSymbol(const DataIndex& name, const uint64_t& addr)
1085 {
1086 addrs_.emplace_back(addr);
1087 funcName_.emplace_back(name);
1088 }
GetConstFuncNames() const1089 const std::deque<DataIndex>& SymbolsData::GetConstFuncNames() const
1090 {
1091 return funcName_;
1092 }
GetConstAddrs() const1093 const std::deque<uint64_t>& SymbolsData::GetConstAddrs() const
1094 {
1095 return addrs_;
1096 }
MetaData()1097 MetaData::MetaData()
1098 {
1099 columnNames_.resize(METADATA_ITEM_MAX);
1100 values_.resize(METADATA_ITEM_MAX);
1101 columnNames_[METADATA_ITEM_DATASIZE] = METADATA_ITEM_DATASIZE_COLNAME;
1102 columnNames_[METADATA_ITEM_PARSETOOL_NAME] = METADATA_ITEM_PARSETOOL_NAME_COLNAME;
1103 columnNames_[METADATA_ITEM_PARSERTOOL_VERSION] = METADATA_ITEM_PARSERTOOL_VERSION_COLNAME;
1104 columnNames_[METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME] = METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME_COLNAME;
1105 columnNames_[METADATA_ITEM_SOURCE_FILENAME] = METADATA_ITEM_SOURCE_FILENAME_COLNAME;
1106 columnNames_[METADATA_ITEM_OUTPUT_FILENAME] = METADATA_ITEM_OUTPUT_FILENAME_COLNAME;
1107 columnNames_[METADATA_ITEM_PARSERTIME] = METADATA_ITEM_PARSERTIME_COLNAME;
1108 columnNames_[METADATA_ITEM_TRACE_DURATION] = METADATA_ITEM_TRACE_DURATION_COLNAME;
1109 columnNames_[METADATA_ITEM_SOURCE_DATETYPE] = METADATA_ITEM_SOURCE_DATETYPE_COLNAME;
1110 values_[METADATA_ITEM_PARSETOOL_NAME] = "trace_streamer";
1111 }
SetTraceType(const std::string & traceType)1112 void MetaData::SetTraceType(const std::string& traceType)
1113 {
1114 values_[METADATA_ITEM_SOURCE_DATETYPE] = traceType;
1115 }
SetSourceFileName(const std::string & fileName)1116 void MetaData::SetSourceFileName(const std::string& fileName)
1117 {
1118 MetaData::values_[METADATA_ITEM_SOURCE_FILENAME] = fileName;
1119 }
SetOutputFileName(const std::string & fileName)1120 void MetaData::SetOutputFileName(const std::string& fileName)
1121 {
1122 MetaData::values_[METADATA_ITEM_OUTPUT_FILENAME] = fileName;
1123 }
SetParserToolVersion(const std::string & version)1124 void MetaData::SetParserToolVersion(const std::string& version)
1125 {
1126 values_[METADATA_ITEM_PARSERTOOL_VERSION] = version;
1127 }
SetParserToolPublishDateTime(const std::string & datetime)1128 void MetaData::SetParserToolPublishDateTime(const std::string& datetime)
1129 {
1130 values_[METADATA_ITEM_PARSERTOOL_PUBLISH_DATETIME] = datetime;
1131 }
SetTraceDataSize(uint64_t dataSize)1132 void MetaData::SetTraceDataSize(uint64_t dataSize)
1133 {
1134 std::stringstream ss;
1135 ss << dataSize;
1136 values_[METADATA_ITEM_DATASIZE] = ss.str();
1137 // Function 'time' may return error. It is not allowed to do anything that might fail inside the constructor.
1138 time_t rawtime;
1139 struct tm* timeinfo = nullptr;
1140 void(time(&rawtime));
1141 timeinfo = localtime(&rawtime);
1142 char buffer[MAX_SIZE_LEN];
1143 strftime(buffer, MAX_SIZE_LEN, "%Y-%m-%d %H:%M:%S", timeinfo);
1144 values_[METADATA_ITEM_PARSERTIME].append(buffer);
1145 // sometimes there will be a extra \n at last
1146 values_[METADATA_ITEM_PARSERTIME].pop_back();
1147 }
SetTraceDuration(uint64_t dur)1148 void MetaData::SetTraceDuration(uint64_t dur)
1149 {
1150 values_[METADATA_ITEM_TRACE_DURATION] = std::to_string(dur) + " s";
1151 }
Value(uint64_t row) const1152 const std::string& MetaData::Value(uint64_t row) const
1153 {
1154 return values_[row];
1155 }
Name(uint64_t row) const1156 const std::string& MetaData::Name(uint64_t row) const
1157 {
1158 return columnNames_[row];
1159 }
GetStringIndex(std::string_view str)1160 DataIndex DataDict::GetStringIndex(std::string_view str)
1161 {
1162 auto hashValue = hashFun(str);
1163 auto itor = dataDictInnerMap_.find(hashValue);
1164 if (itor != dataDictInnerMap_.end()) {
1165 return itor->second;
1166 }
1167 mutex_.lock();
1168 dataDict_.emplace_back(std::string(str));
1169 DataIndex stringIdentity = dataDict_.size() - 1;
1170 dataDictInnerMap_.emplace(hashValue, stringIdentity);
1171 mutex_.unlock();
1172 return stringIdentity;
1173 }
GetStringIndexNoWrite(std::string_view str) const1174 DataIndex DataDict::GetStringIndexNoWrite(std::string_view str) const
1175 {
1176 auto hashValue = hashFun(str);
1177 auto itor = dataDictInnerMap_.find(hashValue);
1178 if (itor != dataDictInnerMap_.end()) {
1179 return itor->second;
1180 }
1181 return INVALID_UINT64;
1182 }
AppendNewData(uint64_t newTimeStamp,uint64_t dur,double totalLoad,double userLoad,double systemLoad,int64_t threads)1183 size_t CpuUsageDetailData::AppendNewData(uint64_t newTimeStamp,
1184 uint64_t dur,
1185 double totalLoad,
1186 double userLoad,
1187 double systemLoad,
1188 int64_t threads)
1189 {
1190 timeStamps_.emplace_back(newTimeStamp);
1191 durs_.emplace_back(dur);
1192 totalLoad_.emplace_back(totalLoad);
1193 userLoad_.emplace_back(userLoad);
1194 systemLoad_.emplace_back(systemLoad);
1195 threads_.emplace_back(threads);
1196 return Size() - 1;
1197 }
Durs() const1198 const std::deque<uint64_t>& CpuUsageDetailData::Durs() const
1199 {
1200 return durs_;
1201 }
TotalLoad() const1202 const std::deque<double>& CpuUsageDetailData::TotalLoad() const
1203 {
1204 return totalLoad_;
1205 }
UserLoad() const1206 const std::deque<double>& CpuUsageDetailData::UserLoad() const
1207 {
1208 return userLoad_;
1209 }
SystemLoad() const1210 const std::deque<double>& CpuUsageDetailData::SystemLoad() const
1211 {
1212 return systemLoad_;
1213 }
Threads() const1214 const std::deque<int64_t>& CpuUsageDetailData::Threads() const
1215 {
1216 return threads_;
1217 }
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)1218 size_t LiveProcessDetailData::AppendNewData(uint64_t newTimeStamp,
1219 uint64_t dur,
1220 int32_t processID,
1221 std::string processName,
1222 int32_t parentProcessID,
1223 int32_t uid,
1224 std::string userName,
1225 double cpuUsage,
1226 int32_t pssInfo,
1227 uint64_t cpuTime,
1228 int32_t threads,
1229 int64_t diskWrites,
1230 int64_t diskReads)
1231 {
1232 timeStamps_.emplace_back(newTimeStamp);
1233 durs_.emplace_back(dur);
1234 processID_.emplace_back(processID);
1235 processName_.emplace_back(processName);
1236 parentProcessID_.emplace_back(parentProcessID);
1237 uid_.emplace_back(uid);
1238 userName_.emplace_back(userName);
1239 cpuUsage_.emplace_back(cpuUsage);
1240 pssInfo_.emplace_back(pssInfo);
1241 threads_.emplace_back(threads);
1242 diskWrites_.emplace_back(diskWrites);
1243 diskReads_.emplace_back(diskReads);
1244 cpuTimes_.emplace_back(cpuTime);
1245 return Size() - 1;
1246 }
Durs() const1247 const std::deque<uint64_t>& LiveProcessDetailData::Durs() const
1248 {
1249 return durs_;
1250 }
ProcessID() const1251 const std::deque<int32_t>& LiveProcessDetailData::ProcessID() const
1252 {
1253 return processID_;
1254 }
ProcessName() const1255 const std::deque<std::string>& LiveProcessDetailData::ProcessName() const
1256 {
1257 return processName_;
1258 }
ParentProcessID() const1259 const std::deque<int32_t>& LiveProcessDetailData::ParentProcessID() const
1260 {
1261 return parentProcessID_;
1262 }
Uid() const1263 const std::deque<int32_t>& LiveProcessDetailData::Uid() const
1264 {
1265 return uid_;
1266 }
UserName() const1267 const std::deque<std::string>& LiveProcessDetailData::UserName() const
1268 {
1269 return userName_;
1270 }
CpuUsage() const1271 const std::deque<double>& LiveProcessDetailData::CpuUsage() const
1272 {
1273 return cpuUsage_;
1274 }
PssInfo() const1275 const std::deque<int32_t>& LiveProcessDetailData::PssInfo() const
1276 {
1277 return pssInfo_;
1278 }
Threads() const1279 const std::deque<int32_t>& LiveProcessDetailData::Threads() const
1280 {
1281 return threads_;
1282 }
DiskWrites() const1283 const std::deque<int64_t>& LiveProcessDetailData::DiskWrites() const
1284 {
1285 return diskWrites_;
1286 }
DiskReads() const1287 const std::deque<int64_t>& LiveProcessDetailData::DiskReads() const
1288 {
1289 return diskReads_;
1290 }
1291
CpuTimes() const1292 const std::deque<uint64_t>& LiveProcessDetailData::CpuTimes() const
1293 {
1294 return cpuTimes_;
1295 }
1296
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)1297 size_t NetDetailData::AppendNewNetData(uint64_t newTimeStamp,
1298 uint64_t tx,
1299 uint64_t rx,
1300 uint64_t dur,
1301 double rxSpeed,
1302 double txSpeed,
1303 uint64_t packetIn,
1304 double packetInSec,
1305 uint64_t packetOut,
1306 double packetOutSec,
1307 const std::string& netType)
1308 {
1309 timeStamps_.emplace_back(newTimeStamp);
1310 txs_.emplace_back(tx);
1311 rxs_.emplace_back(rx);
1312 durs_.emplace_back(dur);
1313 txSpeeds_.emplace_back(txSpeed);
1314 rxSpeeds_.emplace_back(rxSpeed);
1315 netTypes_.emplace_back(netType);
1316 packetIn_.emplace_back(packetIn);
1317 packetInSec_.emplace_back(packetInSec);
1318 packetOut_.emplace_back(packetOut);
1319 packetOutSec_.emplace_back(packetOutSec);
1320
1321 return Size() - 1;
1322 }
Durs() const1323 const std::deque<uint64_t>& NetDetailData::Durs() const
1324 {
1325 return durs_;
1326 }
RxSpeed() const1327 const std::deque<double>& NetDetailData::RxSpeed() const
1328 {
1329 return rxSpeeds_;
1330 }
TxSpeed() const1331 const std::deque<double>& NetDetailData::TxSpeed() const
1332 {
1333 return txSpeeds_;
1334 }
NetTypes() const1335 const std::deque<std::string>& NetDetailData::NetTypes() const
1336 {
1337 return netTypes_;
1338 }
RxDatas() const1339 const std::deque<uint64_t>& NetDetailData::RxDatas() const
1340 {
1341 return rxs_;
1342 }
TxDatas() const1343 const std::deque<uint64_t>& NetDetailData::TxDatas() const
1344 {
1345 return txs_;
1346 }
PacketIn() const1347 const std::deque<uint64_t>& NetDetailData::PacketIn() const
1348 {
1349 return packetIn_;
1350 }
PacketInSec() const1351 const std::deque<double>& NetDetailData::PacketInSec() const
1352 {
1353 return packetInSec_;
1354 }
PacketOut() const1355 const std::deque<uint64_t>& NetDetailData::PacketOut() const
1356 {
1357 return packetOut_;
1358 }
PacketOutSec() const1359 const std::deque<double>& NetDetailData::PacketOutSec() const
1360 {
1361 return packetOutSec_;
1362 }
1363
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)1364 void DiskIOData::AppendNewData(uint64_t ts,
1365 uint64_t dur,
1366 uint64_t rd,
1367 uint64_t wr,
1368 uint64_t rdPerSec,
1369 uint64_t wrPerSec,
1370 double rdCountPerSec,
1371 double wrCountPerSec,
1372 uint64_t rdCount,
1373 uint64_t wrCount)
1374 {
1375 timeStamps_.emplace_back(ts);
1376 durs_.emplace_back(dur);
1377 rdDatas_.emplace_back(rd);
1378 wrDatas_.emplace_back(wr);
1379 rdPerSec_.emplace_back(rdPerSec);
1380 wrPerSec_.emplace_back(wrPerSec);
1381 rdCountPerSec_.emplace_back(rdCountPerSec);
1382 wrCountPerSec_.emplace_back(wrCountPerSec);
1383 rdCountDatas_.emplace_back(rdCount);
1384 wrCountDatas_.emplace_back(wrCount);
1385 }
Durs() const1386 const std::deque<uint64_t>& DiskIOData::Durs() const
1387 {
1388 return durs_;
1389 }
RdDatas() const1390 const std::deque<uint64_t>& DiskIOData::RdDatas() const
1391 {
1392 return rdDatas_;
1393 }
WrDatas() const1394 const std::deque<uint64_t>& DiskIOData::WrDatas() const
1395 {
1396 return wrDatas_;
1397 }
RdSpeedDatas() const1398 const std::deque<double>& DiskIOData::RdSpeedDatas() const
1399 {
1400 return rdPerSec_;
1401 }
WrSpeedDatas() const1402 const std::deque<double>& DiskIOData::WrSpeedDatas() const
1403 {
1404 return wrPerSec_;
1405 }
1406
RdCountPerSecDatas() const1407 const std::deque<double>& DiskIOData::RdCountPerSecDatas() const
1408 {
1409 return rdCountPerSec_;
1410 }
WrCountPerSecDatas() const1411 const std::deque<double>& DiskIOData::WrCountPerSecDatas() const
1412 {
1413 return wrCountPerSec_;
1414 }
RdCountDatas() const1415 const std::deque<uint64_t>& DiskIOData::RdCountDatas() const
1416 {
1417 return rdCountDatas_;
1418 }
WrCountDatas() const1419 const std::deque<uint64_t>& DiskIOData::WrCountDatas() const
1420 {
1421 return wrCountDatas_;
1422 }
1423
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)1424 size_t FileSystemSample::AppendNewData(uint32_t callChainId,
1425 uint16_t type,
1426 uint32_t ipid,
1427 uint32_t itid,
1428 uint64_t startTs,
1429 uint64_t endTs,
1430 uint64_t dur,
1431 DataIndex returnValue,
1432 DataIndex errorCode,
1433 size_t size,
1434 int32_t fd,
1435 DataIndex fileId,
1436 DataIndex firstArgument,
1437 DataIndex secondArgument,
1438 DataIndex thirdArgument,
1439 DataIndex fourthArgument)
1440 {
1441 callChainIds_.emplace_back(callChainId);
1442 types_.emplace_back(type);
1443 ipids_.emplace_back(ipid);
1444 itids_.emplace_back(itid);
1445 startTs_.emplace_back(startTs);
1446 endTs_.emplace_back(endTs);
1447 durs_.emplace_back(dur);
1448 returnValues_.emplace_back(returnValue);
1449 errorCodes_.emplace_back(errorCode);
1450 fds_.emplace_back(fd);
1451 fileIds_.emplace_back(fileId);
1452 Sizes_.emplace_back(size);
1453 firstArguments_.emplace_back(firstArgument);
1454 secondArguments_.emplace_back(secondArgument);
1455 thirdArguments_.emplace_back(thirdArgument);
1456 fourthArguments_.emplace_back(fourthArgument);
1457 ids_.emplace_back(Size());
1458 return Size() - 1;
1459 }
CallChainIds() const1460 const std::deque<uint32_t>& FileSystemSample::CallChainIds() const
1461 {
1462 return callChainIds_;
1463 }
Types() const1464 const std::deque<uint16_t>& FileSystemSample::Types() const
1465 {
1466 return types_;
1467 }
Ipids() const1468 const std::deque<uint32_t>& FileSystemSample::Ipids() const
1469 {
1470 return ipids_;
1471 }
Itids() const1472 const std::deque<uint32_t>& FileSystemSample::Itids() const
1473 {
1474 return itids_;
1475 }
StartTs() const1476 const std::deque<uint64_t>& FileSystemSample::StartTs() const
1477 {
1478 return startTs_;
1479 }
EndTs() const1480 const std::deque<uint64_t>& FileSystemSample::EndTs() const
1481 {
1482 return endTs_;
1483 }
Durs() const1484 const std::deque<uint64_t>& FileSystemSample::Durs() const
1485 {
1486 return durs_;
1487 }
ReturnValues() const1488 const std::deque<DataIndex>& FileSystemSample::ReturnValues() const
1489 {
1490 return returnValues_;
1491 }
ErrorCodes() const1492 const std::deque<DataIndex>& FileSystemSample::ErrorCodes() const
1493 {
1494 return errorCodes_;
1495 }
Fds() const1496 const std::deque<int32_t>& FileSystemSample::Fds() const
1497 {
1498 return fds_;
1499 }
FileIds() const1500 const std::deque<DataIndex>& FileSystemSample::FileIds() const
1501 {
1502 return fileIds_;
1503 }
Sizes() const1504 const std::deque<size_t>& FileSystemSample::Sizes() const
1505 {
1506 return Sizes_;
1507 }
FirstArguments() const1508 const std::deque<DataIndex>& FileSystemSample::FirstArguments() const
1509 {
1510 return firstArguments_;
1511 }
SecondArguments() const1512 const std::deque<DataIndex>& FileSystemSample::SecondArguments() const
1513 {
1514 return secondArguments_;
1515 }
ThirdArguments() const1516 const std::deque<DataIndex>& FileSystemSample::ThirdArguments() const
1517 {
1518 return thirdArguments_;
1519 }
FourthArguments() const1520 const std::deque<DataIndex>& FileSystemSample::FourthArguments() const
1521 {
1522 return fourthArguments_;
1523 }
1524
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)1525 size_t PagedMemorySampleData::AppendNewData(uint32_t callChainId,
1526 uint16_t type,
1527 uint32_t ipid,
1528 uint64_t startTs,
1529 uint64_t endTs,
1530 uint64_t dur,
1531 size_t size,
1532 DataIndex addr,
1533 uint32_t itid)
1534 {
1535 callChainIds_.emplace_back(callChainId);
1536 types_.emplace_back(type);
1537 ipids_.emplace_back(ipid);
1538 startTs_.emplace_back(startTs);
1539 endTs_.emplace_back(endTs);
1540 durs_.emplace_back(dur);
1541 Sizes_.emplace_back(size);
1542 addrs_.emplace_back(addr);
1543 itids_.emplace_back(itid);
1544 ids_.emplace_back(Size());
1545 return Size() - 1;
1546 }
CallChainIds() const1547 const std::deque<uint32_t>& PagedMemorySampleData::CallChainIds() const
1548 {
1549 return callChainIds_;
1550 }
Types() const1551 const std::deque<uint16_t>& PagedMemorySampleData::Types() const
1552 {
1553 return types_;
1554 }
Ipids() const1555 const std::deque<uint32_t>& PagedMemorySampleData::Ipids() const
1556 {
1557 return ipids_;
1558 }
Itids() const1559 const std::deque<uint32_t>& PagedMemorySampleData::Itids() const
1560 {
1561 return itids_;
1562 }
StartTs() const1563 const std::deque<uint64_t>& PagedMemorySampleData::StartTs() const
1564 {
1565 return startTs_;
1566 }
EndTs() const1567 const std::deque<uint64_t>& PagedMemorySampleData::EndTs() const
1568 {
1569 return endTs_;
1570 }
Durs() const1571 const std::deque<uint64_t>& PagedMemorySampleData::Durs() const
1572 {
1573 return durs_;
1574 }
Sizes() const1575 const std::deque<size_t>& PagedMemorySampleData::Sizes() const
1576 {
1577 return Sizes_;
1578 }
Addr() const1579 const std::deque<DataIndex>& PagedMemorySampleData::Addr() const
1580 {
1581 return addrs_;
1582 }
1583
AppendNewData(uint32_t callChainId,uint32_t depth,DataIndex ip,DataIndex symbolId,DataIndex filePathId)1584 size_t EbpfCallStackData::AppendNewData(uint32_t callChainId,
1585 uint32_t depth,
1586 DataIndex ip,
1587 DataIndex symbolId,
1588 DataIndex filePathId)
1589 {
1590 callChainIds_.emplace_back(callChainId);
1591 depths_.emplace_back(depth);
1592 ips_.emplace_back(ip);
1593 symbolIds_.emplace_back(symbolId);
1594 filePathIds_.emplace_back(filePathId);
1595 ids_.emplace_back(Size());
1596 return Size() - 1;
1597 }
UpdateSymbolAndFilePathIndex(size_t row,DataIndex symbolId,DataIndex filePathId)1598 void EbpfCallStackData::UpdateSymbolAndFilePathIndex(size_t row, DataIndex symbolId, DataIndex filePathId)
1599 {
1600 if (row >= Size()) {
1601 TS_LOGE("The updated row does not exist!");
1602 return;
1603 }
1604 symbolIds_[row] = symbolId;
1605 filePathIds_[row] = filePathId;
1606 }
CallChainIds() const1607 const std::deque<uint32_t>& EbpfCallStackData::CallChainIds() const
1608 {
1609 return callChainIds_;
1610 }
Depths() const1611 const std::deque<uint32_t>& EbpfCallStackData::Depths() const
1612 {
1613 return depths_;
1614 }
Ips() const1615 const std::deque<DataIndex>& EbpfCallStackData::Ips() const
1616 {
1617 return ips_;
1618 }
SymbolIds() const1619 const std::deque<DataIndex>& EbpfCallStackData::SymbolIds() const
1620 {
1621 return symbolIds_;
1622 }
FilePathIds() const1623 const std::deque<DataIndex>& EbpfCallStackData::FilePathIds() const
1624 {
1625 return filePathIds_;
1626 }
1627 #if WITH_EBPF_HELP
AppendNewData(uint64_t start,uint64_t end,uint32_t offset,uint32_t pid,uint32_t fileNameLen,uint64_t fileNameIndex)1628 size_t EbpfProcessMaps::AppendNewData(uint64_t start,
1629 uint64_t end,
1630 uint32_t offset,
1631 uint32_t pid,
1632 uint32_t fileNameLen,
1633 uint64_t fileNameIndex)
1634 {
1635 starts_.emplace_back(start);
1636 ends_.emplace_back(end);
1637 offsets_.emplace_back(offset);
1638 pids_.emplace_back(pid);
1639 fileNameLens_.emplace_back(fileNameLen);
1640 fileNameIndexs_.emplace_back(fileNameIndex);
1641 ids_.emplace_back(Size());
1642 return Size() - 1;
1643 }
1644
Starts() const1645 const std::deque<uint64_t>& EbpfProcessMaps::Starts() const
1646 {
1647 return starts_;
1648 }
Ends() const1649 const std::deque<uint64_t>& EbpfProcessMaps::Ends() const
1650 {
1651 return ends_;
1652 }
Offsets() const1653 const std::deque<uint32_t>& EbpfProcessMaps::Offsets() const
1654 {
1655 return offsets_;
1656 }
Pids() const1657 const std::deque<uint32_t>& EbpfProcessMaps::Pids() const
1658 {
1659 return pids_;
1660 }
FileNameLens() const1661 const std::deque<uint32_t>& EbpfProcessMaps::FileNameLens() const
1662 {
1663 return fileNameLens_;
1664 }
FileNameIndexs() const1665 const std::deque<uint64_t>& EbpfProcessMaps::FileNameIndexs() const
1666 {
1667 return fileNameIndexs_;
1668 }
1669
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)1670 size_t EbpfElf::AppendNewData(uint64_t elfId,
1671 uint64_t textVaddr,
1672 uint32_t textOffset,
1673 uint32_t strTabLen,
1674 uint32_t symTabLen,
1675 uint32_t fileNameLen,
1676 uint32_t symEntLen,
1677 uint64_t fileNameIndex)
1678 {
1679 elfIds_.emplace_back(elfId);
1680 textVaddrs_.emplace_back(textVaddr);
1681 textOffsets_.emplace_back(textOffset);
1682 strTabLens_.emplace_back(strTabLen);
1683 symTabLens_.emplace_back(symTabLen);
1684 fileNameLens_.emplace_back(fileNameLen);
1685 symEntLens_.emplace_back(symEntLen);
1686 fileNameIndexs_.emplace_back(fileNameIndex);
1687 ids_.emplace_back(Size());
1688 return Size() - 1;
1689 }
ElfIds() const1690 const std::deque<uint64_t>& EbpfElf::ElfIds() const
1691 {
1692 return elfIds_;
1693 }
TextVaddrs() const1694 const std::deque<uint64_t>& EbpfElf::TextVaddrs() const
1695 {
1696 return textVaddrs_;
1697 }
TextOffsets() const1698 const std::deque<uint32_t>& EbpfElf::TextOffsets() const
1699 {
1700 return textOffsets_;
1701 }
StrTabLens() const1702 const std::deque<uint32_t>& EbpfElf::StrTabLens() const
1703 {
1704 return strTabLens_;
1705 }
SymTabLens() const1706 const std::deque<uint32_t>& EbpfElf::SymTabLens() const
1707 {
1708 return symTabLens_;
1709 }
FileNameLens() const1710 const std::deque<uint32_t>& EbpfElf::FileNameLens() const
1711 {
1712 return fileNameLens_;
1713 }
SymEntLens() const1714 const std::deque<uint32_t>& EbpfElf::SymEntLens() const
1715 {
1716 return symEntLens_;
1717 }
FileNameIndexs() const1718 const std::deque<uint64_t>& EbpfElf::FileNameIndexs() const
1719 {
1720 return fileNameIndexs_;
1721 }
1722
AppendNewData(uint64_t elfId,uint32_t stName,uint64_t stValue,uint64_t stSize)1723 size_t EbpfElfSymbol::AppendNewData(uint64_t elfId, uint32_t stName, uint64_t stValue, uint64_t stSize)
1724 {
1725 elfIds_.emplace_back(elfId);
1726 stNames_.emplace_back(stName);
1727 stValues_.emplace_back(stValue);
1728 stSizes_.emplace_back(stSize);
1729 ids_.emplace_back(Size());
1730 return Size() - 1;
1731 }
ElfIds() const1732 const std::deque<uint64_t>& EbpfElfSymbol::ElfIds() const
1733 {
1734 return elfIds_;
1735 }
StNames() const1736 const std::deque<uint32_t>& EbpfElfSymbol::StNames() const
1737 {
1738 return stNames_;
1739 }
StValues() const1740 const std::deque<uint64_t>& EbpfElfSymbol::StValues() const
1741 {
1742 return stValues_;
1743 }
StSizes() const1744 const std::deque<uint64_t>& EbpfElfSymbol::StSizes() const
1745 {
1746 return stSizes_;
1747 }
1748 #endif
AppendAppName(uint8_t flags,DataIndex eventSource,DataIndex appName)1749 uint32_t AppNames::AppendAppName(uint8_t flags, DataIndex eventSource, DataIndex appName)
1750 {
1751 flags_.push_back(flags);
1752 appNames_.push_back(eventSource);
1753 keyNames_.push_back(appName);
1754 ids_.push_back(keyNames_.size() - 1);
1755 return Size() - 1;
1756 }
Falgs() const1757 const std::deque<uint8_t>& AppNames::Falgs() const
1758 {
1759 return flags_;
1760 }
EventSourceId() const1761 const std::deque<DataIndex>& AppNames::EventSourceId() const
1762 {
1763 return appNames_;
1764 }
AppName() const1765 const std::deque<DataIndex>& AppNames::AppName() const
1766 {
1767 return keyNames_;
1768 }
1769
AppendData(uint64_t serial,uint64_t ts,uint32_t nameId,uint32_t keyId,int32_t type,double numericValue,DataIndex stringValue)1770 void SysEventMeasureData::AppendData(uint64_t serial,
1771 uint64_t ts,
1772 uint32_t nameId,
1773 uint32_t keyId,
1774 int32_t type,
1775 double numericValue,
1776 DataIndex stringValue)
1777 {
1778 serial_.emplace_back(serial);
1779 ts_.emplace_back(ts);
1780 nameFilterIds_.emplace_back(nameId);
1781 appKeyFilterIds_.emplace_back(keyId);
1782 types_.emplace_back(type);
1783 numValues_.emplace_back(numericValue);
1784 stringValues_.emplace_back(stringValue);
1785 ids_.push_back(rowCount_);
1786 rowCount_++;
1787 }
Serial() const1788 const std::deque<uint64_t>& SysEventMeasureData::Serial() const
1789 {
1790 return serial_;
1791 }
Ts() const1792 const std::deque<uint64_t>& SysEventMeasureData::Ts() const
1793 {
1794 return ts_;
1795 }
NameFilterId() const1796 const std::deque<uint32_t>& SysEventMeasureData::NameFilterId() const
1797 {
1798 return nameFilterIds_;
1799 }
AppKeyFilterId() const1800 const std::deque<uint32_t>& SysEventMeasureData::AppKeyFilterId() const
1801 {
1802 return appKeyFilterIds_;
1803 }
Type() const1804 const std::deque<int32_t>& SysEventMeasureData::Type() const
1805 {
1806 return types_;
1807 }
NumValue() const1808 const std::deque<double>& SysEventMeasureData::NumValue() const
1809 {
1810 return numValues_;
1811 }
StringValue() const1812 const std::deque<DataIndex>& SysEventMeasureData::StringValue() const
1813 {
1814 return stringValues_;
1815 }
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)1816 void DeviceStateData::AppendNewData(int32_t brightness,
1817 int32_t btState,
1818 int32_t location,
1819 int32_t wifi,
1820 int32_t streamDefault,
1821 int32_t voiceCall,
1822 int32_t music,
1823 int32_t streamRing,
1824 int32_t media,
1825 int32_t voiceAssistant,
1826 int32_t system,
1827 int32_t alarm,
1828 int32_t notification,
1829 int32_t btSco,
1830 int32_t enforcedAudible,
1831 int32_t streamDtmf,
1832 int32_t streamTts,
1833 int32_t accessibility,
1834 int32_t recording,
1835 int32_t streamAll)
1836 {
1837 brightness_.emplace_back(brightness);
1838 btStates_.emplace_back(btState);
1839 locations_.emplace_back(location);
1840 wifis_.emplace_back(wifi);
1841 streamDefaults_.emplace_back(streamDefault);
1842 voiceCalls_.emplace_back(voiceCall);
1843 musics_.emplace_back(music);
1844 streamRings_.emplace_back(streamRing);
1845 medias_.emplace_back(media);
1846 voiceAssistants_.emplace_back(voiceAssistant);
1847 systems_.emplace_back(system);
1848 alarms_.emplace_back(alarm);
1849 notifications_.emplace_back(notification);
1850 btScos_.emplace_back(btSco);
1851 enforcedAudibles_.emplace_back(enforcedAudible);
1852 streamDtmfs_.emplace_back(streamDtmf);
1853 streamTts_.emplace_back(streamTts);
1854 accessibilitys_.emplace_back(accessibility);
1855 recordings_.emplace_back(recording);
1856 streamAlls_.emplace_back(streamAll);
1857 ids_.push_back(rowCounts_);
1858 rowCounts_++;
1859 }
Brightness() const1860 const std::deque<int32_t>& DeviceStateData::Brightness() const
1861 {
1862 return brightness_;
1863 }
BtState() const1864 const std::deque<int32_t>& DeviceStateData::BtState() const
1865 {
1866 return btStates_;
1867 }
Location() const1868 const std::deque<int32_t>& DeviceStateData::Location() const
1869 {
1870 return locations_;
1871 }
Wifi() const1872 const std::deque<int32_t>& DeviceStateData::Wifi() const
1873 {
1874 return wifis_;
1875 }
StreamDefault() const1876 const std::deque<int32_t>& DeviceStateData::StreamDefault() const
1877 {
1878 return streamDefaults_;
1879 }
VoiceCall() const1880 const std::deque<int32_t>& DeviceStateData::VoiceCall() const
1881 {
1882 return voiceCalls_;
1883 }
Music() const1884 const std::deque<int32_t>& DeviceStateData::Music() const
1885 {
1886 return musics_;
1887 }
StreamRing() const1888 const std::deque<int32_t>& DeviceStateData::StreamRing() const
1889 {
1890 return streamRings_;
1891 }
Media() const1892 const std::deque<int32_t>& DeviceStateData::Media() const
1893 {
1894 return medias_;
1895 }
VoiceAssistant() const1896 const std::deque<int32_t>& DeviceStateData::VoiceAssistant() const
1897 {
1898 return voiceAssistants_;
1899 }
System() const1900 const std::deque<int32_t>& DeviceStateData::System() const
1901 {
1902 return systems_;
1903 }
Alarm() const1904 const std::deque<int32_t>& DeviceStateData::Alarm() const
1905 {
1906 return alarms_;
1907 }
Notification() const1908