1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "arkts_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendNewData(uint32_t id,std::string filePath,uint64_t startTime,uint64_t endTime,uint64_t selfSizeCount)19 size_t JsHeapFiles::AppendNewData(uint32_t id,
20 std::string filePath,
21 uint64_t startTime,
22 uint64_t endTime,
23 uint64_t selfSizeCount)
24 {
25 fileIds_.emplace_back(id);
26 filePaths_.emplace_back(filePath);
27 startTimes_.emplace_back(startTime);
28 endTimes_.emplace_back(endTime);
29 selfSizeCount_.emplace_back(selfSizeCount);
30 ids_.emplace_back(Size());
31 return Size() - 1;
32 }
IDs() const33 const std::deque<uint32_t> &JsHeapFiles::IDs() const
34 {
35 return fileIds_;
36 }
FilePaths() const37 const std::deque<std::string> &JsHeapFiles::FilePaths() const
38 {
39 return filePaths_;
40 }
StartTimes() const41 const std::deque<uint64_t> &JsHeapFiles::StartTimes() const
42 {
43 return startTimes_;
44 }
EndTimes() const45 const std::deque<uint64_t> &JsHeapFiles::EndTimes() const
46 {
47 return endTimes_;
48 }
49
SelfSizeCount() const50 const std::deque<uint64_t> &JsHeapFiles::SelfSizeCount() const
51 {
52 return selfSizeCount_;
53 }
54
AppendNewData(const JsHeapEdgesRow & jsHeapEdgesRow)55 size_t JsHeapEdges::AppendNewData(const JsHeapEdgesRow &jsHeapEdgesRow)
56 {
57 fileIds_.emplace_back(jsHeapEdgesRow.fileId);
58 edgeIndexs_.emplace_back(jsHeapEdgesRow.edgeIndex);
59 types_.emplace_back(jsHeapEdgesRow.type);
60 nameOrIndexs_.emplace_back(jsHeapEdgesRow.nameOrIndex);
61 toNodes_.emplace_back(jsHeapEdgesRow.toNode);
62 fromNodeIds_.emplace_back(jsHeapEdgesRow.fromNodeId);
63 toNodeIds_.emplace_back(jsHeapEdgesRow.toNodeId);
64 ids_.emplace_back(Size());
65 return Size() - 1;
66 }
67
FileIds() const68 const std::deque<uint32_t> &JsHeapEdges::FileIds() const
69 {
70 return fileIds_;
71 }
EdgeIndexs() const72 const std::deque<uint32_t> &JsHeapEdges::EdgeIndexs() const
73 {
74 return edgeIndexs_;
75 }
Types() const76 const std::deque<uint32_t> &JsHeapEdges::Types() const
77 {
78 return types_;
79 }
NameOrIndexs() const80 const std::deque<uint32_t> &JsHeapEdges::NameOrIndexs() const
81 {
82 return nameOrIndexs_;
83 }
ToNodes() const84 const std::deque<uint32_t> &JsHeapEdges::ToNodes() const
85 {
86 return toNodes_;
87 }
FromNodeIds() const88 const std::deque<uint32_t> &JsHeapEdges::FromNodeIds() const
89 {
90 return fromNodeIds_;
91 }
ToNodeIds() const92 const std::deque<uint32_t> &JsHeapEdges::ToNodeIds() const
93 {
94 return toNodeIds_;
95 }
96
AppendNewData(uint32_t fileId,std::string key,uint32_t type,int32_t intValue,std::string strValue)97 size_t JsHeapInfo::AppendNewData(uint32_t fileId,
98 std::string key,
99 uint32_t type,
100 int32_t intValue,
101 std::string strValue)
102 {
103 fileIds_.emplace_back(fileId);
104 keys_.emplace_back(key);
105 types_.emplace_back(type);
106 intValues_.emplace_back(intValue);
107 strValues_.emplace_back(strValue);
108 ids_.emplace_back(Size());
109 return Size() - 1;
110 }
FileIds() const111 const std::deque<uint32_t> &JsHeapInfo::FileIds() const
112 {
113 return fileIds_;
114 }
Keys() const115 const std::deque<std::string> &JsHeapInfo::Keys() const
116 {
117 return keys_;
118 }
Types() const119 const std::deque<uint32_t> &JsHeapInfo::Types() const
120 {
121 return types_;
122 }
IntValues() const123 const std::deque<int32_t> &JsHeapInfo::IntValues() const
124 {
125 return intValues_;
126 }
StrValues() const127 const std::deque<std::string> &JsHeapInfo::StrValues() const
128 {
129 return strValues_;
130 }
131
AppendNewData(uint32_t fileId,uint32_t objectIndex,uint32_t scriptId,uint32_t line,uint32_t column)132 size_t JsHeapLocation::AppendNewData(uint32_t fileId,
133 uint32_t objectIndex,
134 uint32_t scriptId,
135 uint32_t line,
136 uint32_t column)
137 {
138 fileIds_.emplace_back(fileId);
139 objectIndexs_.emplace_back(objectIndex);
140 scriptIds_.emplace_back(scriptId);
141 lines_.emplace_back(line);
142 columns_.emplace_back(column);
143 ids_.emplace_back(Size());
144 return Size() - 1;
145 }
FileIds() const146 const std::deque<uint32_t> &JsHeapLocation::FileIds() const
147 {
148 return fileIds_;
149 }
ObjectIndexs() const150 const std::deque<uint32_t> &JsHeapLocation::ObjectIndexs() const
151 {
152 return objectIndexs_;
153 }
ScriptIds() const154 const std::deque<uint32_t> &JsHeapLocation::ScriptIds() const
155 {
156 return scriptIds_;
157 }
Lines() const158 const std::deque<uint32_t> &JsHeapLocation::Lines() const
159 {
160 return lines_;
161 }
Columns() const162 const std::deque<uint32_t> &JsHeapLocation::Columns() const
163 {
164 return columns_;
165 }
166
AppendNewData(const JsHeapNodesRow & jsHeapNodesRow)167 size_t JsHeapNodes::AppendNewData(const JsHeapNodesRow &jsHeapNodesRow)
168 {
169 fileIds_.emplace_back(jsHeapNodesRow.fileId);
170 nodeIndexs_.emplace_back(jsHeapNodesRow.nodeIndex);
171 types_.emplace_back(jsHeapNodesRow.type);
172 names_.emplace_back(jsHeapNodesRow.name);
173 nodeIds_.emplace_back(jsHeapNodesRow.id);
174 selfSizes_.emplace_back(jsHeapNodesRow.selfSize);
175 edgeCounts_.emplace_back(jsHeapNodesRow.edgeCount);
176 traceNodeIds_.emplace_back(jsHeapNodesRow.traceNodeId);
177 detachedNess_.emplace_back(jsHeapNodesRow.detachedNess);
178 ids_.emplace_back(Size());
179 return Size() - 1;
180 }
FileIds() const181 const std::deque<uint32_t> &JsHeapNodes::FileIds() const
182 {
183 return fileIds_;
184 }
NodeIndexs() const185 const std::deque<uint32_t> &JsHeapNodes::NodeIndexs() const
186 {
187 return nodeIndexs_;
188 }
Types() const189 const std::deque<uint32_t> &JsHeapNodes::Types() const
190 {
191 return types_;
192 }
Names() const193 const std::deque<uint32_t> &JsHeapNodes::Names() const
194 {
195 return names_;
196 }
NodeIds() const197 const std::deque<uint32_t> &JsHeapNodes::NodeIds() const
198 {
199 return nodeIds_;
200 }
SelfSizes() const201 const std::deque<uint32_t> &JsHeapNodes::SelfSizes() const
202 {
203 return selfSizes_;
204 }
EdgeCounts() const205 const std::deque<uint32_t> &JsHeapNodes::EdgeCounts() const
206 {
207 return edgeCounts_;
208 }
TraceNodeIds() const209 const std::deque<uint32_t> &JsHeapNodes::TraceNodeIds() const
210 {
211 return traceNodeIds_;
212 }
DetachedNess() const213 const std::deque<uint32_t> &JsHeapNodes::DetachedNess() const
214 {
215 return detachedNess_;
216 }
217
AppendNewData(uint32_t fileId,uint64_t timeStampUs,uint32_t lastAssignedId)218 size_t JsHeapSample::AppendNewData(uint32_t fileId, uint64_t timeStampUs, uint32_t lastAssignedId)
219 {
220 fileIds_.emplace_back(fileId);
221 timeStampUs_.emplace_back(timeStampUs);
222 lastAssignedIds_.emplace_back(lastAssignedId);
223 ids_.emplace_back(Size());
224 return Size() - 1;
225 }
FileIds() const226 const std::deque<uint32_t> &JsHeapSample::FileIds() const
227 {
228 return fileIds_;
229 }
TimeStampUs() const230 const std::deque<uint64_t> &JsHeapSample::TimeStampUs() const
231 {
232 return timeStampUs_;
233 }
LastAssignedIds() const234 const std::deque<uint32_t> &JsHeapSample::LastAssignedIds() const
235 {
236 return lastAssignedIds_;
237 }
238
AppendNewData(uint32_t fileId,uint32_t fileIndex,std::string string)239 size_t JsHeapString::AppendNewData(uint32_t fileId, uint32_t fileIndex, std::string string)
240 {
241 fileIds_.emplace_back(fileId);
242 fileIndexs_.emplace_back(fileIndex);
243 strings_.emplace_back(string);
244 ids_.emplace_back(Size());
245 return Size() - 1;
246 }
FileIds() const247 const std::deque<uint32_t> &JsHeapString::FileIds() const
248 {
249 return fileIds_;
250 }
FileIndexs() const251 const std::deque<uint64_t> &JsHeapString::FileIndexs() const
252 {
253 return fileIndexs_;
254 }
Strings() const255 const std::deque<std::string> &JsHeapString::Strings() const
256 {
257 return strings_;
258 }
259
AppendNewData(const JsHeapTraceFuncRow & jsHeapTraceFuncRow)260 size_t JsHeapTraceFuncInfo::AppendNewData(const JsHeapTraceFuncRow &jsHeapTraceFuncRow)
261 {
262 fileIds_.emplace_back(jsHeapTraceFuncRow.fileId);
263 functionIndexs_.emplace_back(jsHeapTraceFuncRow.functionIndex);
264 functionIds_.emplace_back(jsHeapTraceFuncRow.functionId);
265 names_.emplace_back(jsHeapTraceFuncRow.name);
266 scriptNames_.emplace_back(jsHeapTraceFuncRow.scriptName);
267 scriptIds_.emplace_back(jsHeapTraceFuncRow.scriptId);
268 lines_.emplace_back(jsHeapTraceFuncRow.line);
269 columns_.emplace_back(jsHeapTraceFuncRow.column);
270 ids_.emplace_back(Size());
271 return Size() - 1;
272 }
FileIds() const273 const std::deque<uint32_t> &JsHeapTraceFuncInfo::FileIds() const
274 {
275 return fileIds_;
276 }
FunctionIndexs() const277 const std::deque<uint32_t> &JsHeapTraceFuncInfo::FunctionIndexs() const
278 {
279 return functionIndexs_;
280 }
FunctionIds() const281 const std::deque<uint32_t> &JsHeapTraceFuncInfo::FunctionIds() const
282 {
283 return functionIds_;
284 }
Names() const285 const std::deque<uint32_t> &JsHeapTraceFuncInfo::Names() const
286 {
287 return names_;
288 }
ScriptNames() const289 const std::deque<uint32_t> &JsHeapTraceFuncInfo::ScriptNames() const
290 {
291 return scriptNames_;
292 }
ScriptIds() const293 const std::deque<uint32_t> &JsHeapTraceFuncInfo::ScriptIds() const
294 {
295 return scriptIds_;
296 }
Lines() const297 const std::deque<uint32_t> &JsHeapTraceFuncInfo::Lines() const
298 {
299 return lines_;
300 }
Columns() const301 const std::deque<uint32_t> &JsHeapTraceFuncInfo::Columns() const
302 {
303 return columns_;
304 }
AppendNewData(const JsHeapTraceNodeRow & jsHeapTraceNodeRow)305 size_t JsHeapTraceNode::AppendNewData(const JsHeapTraceNodeRow &jsHeapTraceNodeRow)
306 {
307 fileIds_.emplace_back(jsHeapTraceNodeRow.fileId);
308 traceNodeIds_.emplace_back(jsHeapTraceNodeRow.traceNodeId);
309 functionInfoIndexs_.emplace_back(jsHeapTraceNodeRow.functionInfoIndex);
310 counts_.emplace_back(jsHeapTraceNodeRow.count);
311 sizes_.emplace_back(jsHeapTraceNodeRow.size);
312 parentIds_.emplace_back(jsHeapTraceNodeRow.parentId);
313 ids_.emplace_back(Size());
314 return Size() - 1;
315 }
FileIds() const316 const std::deque<uint32_t> &JsHeapTraceNode::FileIds() const
317 {
318 return fileIds_;
319 }
TraceNodeIDs() const320 const std::deque<uint32_t> &JsHeapTraceNode::TraceNodeIDs() const
321 {
322 return traceNodeIds_;
323 }
FunctionInfoIndexs() const324 const std::deque<uint32_t> &JsHeapTraceNode::FunctionInfoIndexs() const
325 {
326 return functionInfoIndexs_;
327 }
Counts() const328 const std::deque<uint32_t> &JsHeapTraceNode::Counts() const
329 {
330 return counts_;
331 }
NodeSizes() const332 const std::deque<uint32_t> &JsHeapTraceNode::NodeSizes() const
333 {
334 return sizes_;
335 }
ParentIds() const336 const std::deque<int32_t> &JsHeapTraceNode::ParentIds() const
337 {
338 return parentIds_;
339 }
AppendNewData(const JsCpuProfilerNodeRow & jsCpuProfilerNodeRow)340 size_t JsCpuProfilerNode::AppendNewData(const JsCpuProfilerNodeRow &jsCpuProfilerNodeRow)
341 {
342 functionIds_.emplace_back(jsCpuProfilerNodeRow.functionId);
343 functionNames_.emplace_back(jsCpuProfilerNodeRow.functionName);
344 scriptIds_.emplace_back(jsCpuProfilerNodeRow.scriptId);
345 urls_.emplace_back(jsCpuProfilerNodeRow.url);
346 lineNumbers_.emplace_back(jsCpuProfilerNodeRow.lineNumber);
347 columnNumbers_.emplace_back(jsCpuProfilerNodeRow.columnNumber);
348 hitCounts_.emplace_back(jsCpuProfilerNodeRow.hitCount);
349 children_.emplace_back(jsCpuProfilerNodeRow.children);
350 parents_.emplace_back(jsCpuProfilerNodeRow.parent);
351 ids_.emplace_back(Size());
352 return Size() - 1;
353 }
354
FunctionIds() const355 const std::deque<uint32_t> &JsCpuProfilerNode::FunctionIds() const
356 {
357 return functionIds_;
358 }
FunctionNames() const359 const std::deque<uint32_t> &JsCpuProfilerNode::FunctionNames() const
360 {
361 return functionNames_;
362 }
ScriptIds() const363 const std::deque<std::string> &JsCpuProfilerNode::ScriptIds() const
364 {
365 return scriptIds_;
366 }
Urls() const367 const std::deque<uint32_t> &JsCpuProfilerNode::Urls() const
368 {
369 return urls_;
370 }
LineNumbers() const371 const std::deque<uint32_t> &JsCpuProfilerNode::LineNumbers() const
372 {
373 return lineNumbers_;
374 }
ColumnNumbers() const375 const std::deque<int32_t> &JsCpuProfilerNode::ColumnNumbers() const
376 {
377 return columnNumbers_;
378 }
HitCounts() const379 const std::deque<int32_t> &JsCpuProfilerNode::HitCounts() const
380 {
381 return hitCounts_;
382 }
Children() const383 const std::deque<std::string> &JsCpuProfilerNode::Children() const
384 {
385 return children_;
386 }
Parents() const387 const std::deque<uint32_t> &JsCpuProfilerNode::Parents() const
388 {
389 return parents_;
390 }
391
AppendNewData(uint32_t functionId,uint64_t startTime,uint64_t endTime,uint64_t dur)392 size_t JsCpuProfilerSample::AppendNewData(uint32_t functionId, uint64_t startTime, uint64_t endTime, uint64_t dur)
393 {
394 functionIds_.emplace_back(functionId);
395 startTimes_.emplace_back(startTime);
396 endTimes_.emplace_back(endTime);
397 durs_.emplace_back(dur);
398 ids_.emplace_back(Size());
399 return Size() - 1;
400 }
FunctionIds() const401 const std::deque<uint32_t> &JsCpuProfilerSample::FunctionIds() const
402 {
403 return functionIds_;
404 }
StartTimes() const405 const std::deque<uint64_t> &JsCpuProfilerSample::StartTimes() const
406 {
407 return startTimes_;
408 }
EndTimes() const409 const std::deque<uint64_t> &JsCpuProfilerSample::EndTimes() const
410 {
411 return endTimes_;
412 }
Durs() const413 const std::deque<uint64_t> &JsCpuProfilerSample::Durs() const
414 {
415 return durs_;
416 }
AppendNewData(const JsConfigRow & jsConfigRow)417 size_t JsConfig::AppendNewData(const JsConfigRow &jsConfigRow)
418 {
419 pids_.emplace_back(jsConfigRow.pid);
420 types_.emplace_back(jsConfigRow.type);
421 intervals_.emplace_back(jsConfigRow.interval);
422 captureNumericValues_.emplace_back(jsConfigRow.captureNumericValue);
423 trackAllocations_.emplace_back(jsConfigRow.trackAllocation);
424 cpuProfilers_.emplace_back(jsConfigRow.cpuProfiler);
425 cpuProfilerIntervals_.emplace_back(jsConfigRow.cpuProfilerInterval);
426 ids_.emplace_back(Size());
427 return Size() - 1;
428 }
Pids() const429 const std::deque<uint32_t> &JsConfig::Pids() const
430 {
431 return pids_;
432 }
Types() const433 const std::deque<uint64_t> &JsConfig::Types() const
434 {
435 return types_;
436 }
Intervals() const437 const std::deque<uint32_t> &JsConfig::Intervals() const
438 {
439 return intervals_;
440 }
CaptureNumericValue() const441 const std::deque<uint32_t> &JsConfig::CaptureNumericValue() const
442 {
443 return captureNumericValues_;
444 }
TrackAllocations() const445 const std::deque<uint32_t> &JsConfig::TrackAllocations() const
446 {
447 return trackAllocations_;
448 }
CpuProfiler() const449 const std::deque<uint32_t> &JsConfig::CpuProfiler() const
450 {
451 return cpuProfilers_;
452 }
CpuProfilerInterval() const453 const std::deque<uint32_t> &JsConfig::CpuProfilerInterval() const
454 {
455 return cpuProfilerIntervals_;
456 }
457 } // namespace TraceStdtype
458 } // namespace SysTuning
459