• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
16 #ifndef ARKTS_STDTYPE_H
17 #define ARKTS_STDTYPE_H
18 #include "base_stdtype.h"
19 
20 namespace SysTuning {
21 namespace TraceStdtype {
22 class JsHeapFiles : public CacheBase {
23 public:
24     size_t AppendNewData(uint32_t id,
25                          std::string filePath,
26                          uint64_t startTime,
27                          uint64_t endTime,
28                          uint64_t selfSizeCount);
29     const std::deque<uint32_t> &IDs() const;
30     const std::deque<std::string> &FilePaths() const;
31     const std::deque<uint64_t> &StartTimes() const;
32     const std::deque<uint64_t> &EndTimes() const;
33     const std::deque<uint64_t> &SelfSizeCount() const;
Clear()34     void Clear() override
35     {
36         CacheBase::Clear();
37         fileIds_.clear();
38         filePaths_.clear();
39         startTimes_.clear();
40         endTimes_.clear();
41         selfSizeCount_.clear();
42     }
43 
44 private:
45     std::deque<uint32_t> fileIds_ = {};
46     std::deque<std::string> filePaths_ = {};
47     std::deque<uint64_t> startTimes_ = {};
48     std::deque<uint64_t> endTimes_ = {};
49     std::deque<uint64_t> selfSizeCount_ = {};
50 };
51 struct JsHeapEdgesRow {
52     uint32_t fileId = INVALID_UINT32;
53     uint32_t edgeIndex = INVALID_UINT32;
54     uint32_t type = INVALID_UINT32;
55     uint32_t nameOrIndex = INVALID_UINT32;
56     uint32_t toNode = INVALID_UINT32;
57     uint32_t fromNodeId = INVALID_UINT32;
58     uint32_t toNodeId = INVALID_UINT32;
59 };
60 class JsHeapEdges : public CacheBase {
61 public:
62     size_t AppendNewData(const JsHeapEdgesRow &jsHeapEdgesRow);
63     const std::deque<uint32_t> &FileIds() const;
64     const std::deque<uint32_t> &EdgeIndexs() const;
65     const std::deque<uint32_t> &Types() const;
66     const std::deque<uint32_t> &NameOrIndexs() const;
67     const std::deque<uint32_t> &ToNodes() const;
68     const std::deque<uint32_t> &FromNodeIds() const;
69     const std::deque<uint32_t> &ToNodeIds() const;
Clear()70     void Clear() override
71     {
72         CacheBase::Clear();
73         fileIds_.clear();
74         edgeIndexs_.clear();
75         types_.clear();
76         nameOrIndexs_.clear();
77         toNodes_.clear();
78         fromNodeIds_.clear();
79         toNodeIds_.clear();
80     }
81 
82 private:
83     std::deque<uint32_t> fileIds_ = {};
84     std::deque<uint32_t> edgeIndexs_ = {};
85     std::deque<uint32_t> types_ = {};
86     std::deque<uint32_t> nameOrIndexs_ = {};
87     std::deque<uint32_t> toNodes_ = {};
88     std::deque<uint32_t> fromNodeIds_ = {};
89     std::deque<uint32_t> toNodeIds_ = {};
90 };
91 
92 class JsHeapInfo : public CacheBase {
93 public:
94     size_t AppendNewData(uint32_t fileId, std::string key, uint32_t type, int32_t intValue, std::string strValue);
95     const std::deque<uint32_t> &FileIds() const;
96     const std::deque<std::string> &Keys() const;
97     const std::deque<uint32_t> &Types() const;
98     const std::deque<int32_t> &IntValues() const;
99     const std::deque<std::string> &StrValues() const;
Clear()100     void Clear() override
101     {
102         CacheBase::Clear();
103         fileIds_.clear();
104         keys_.clear();
105         types_.clear();
106         intValues_.clear();
107         strValues_.clear();
108     }
109 
110 private:
111     std::deque<uint32_t> fileIds_ = {};
112     std::deque<std::string> keys_ = {};
113     std::deque<uint32_t> types_ = {};
114     std::deque<int32_t> intValues_ = {};
115     std::deque<std::string> strValues_ = {};
116 };
117 
118 class JsHeapLocation : public CacheBase {
119 public:
120     size_t AppendNewData(uint32_t fileId, uint32_t objectIndex, uint32_t scriptId, uint32_t line, uint32_t column);
121     const std::deque<uint32_t> &FileIds() const;
122     const std::deque<uint32_t> &ObjectIndexs() const;
123     const std::deque<uint32_t> &ScriptIds() const;
124     const std::deque<uint32_t> &Lines() const;
125     const std::deque<uint32_t> &Columns() const;
Clear()126     void Clear() override
127     {
128         CacheBase::Clear();
129         fileIds_.clear();
130         objectIndexs_.clear();
131         scriptIds_.clear();
132         lines_.clear();
133         columns_.clear();
134     }
135 
136 private:
137     std::deque<uint32_t> fileIds_ = {};
138     std::deque<uint32_t> objectIndexs_ = {};
139     std::deque<uint32_t> scriptIds_ = {};
140     std::deque<uint32_t> lines_ = {};
141     std::deque<uint32_t> columns_ = {};
142 };
143 
144 struct JsHeapNodesRow {
145     uint32_t fileId = INVALID_UINT32;
146     uint32_t nodeIndex = INVALID_UINT32;
147     uint32_t type = INVALID_UINT32;
148     uint32_t name = INVALID_UINT32;
149     uint32_t id = INVALID_UINT32;
150     uint32_t selfSize = INVALID_UINT32;
151     uint32_t edgeCount = INVALID_UINT32;
152     uint32_t traceNodeId = INVALID_UINT32;
153     uint32_t detachedNess = INVALID_UINT32;
154 };
155 class JsHeapNodes : public CacheBase {
156 public:
157     size_t AppendNewData(const JsHeapNodesRow &jsHeapNodesRow);
158     const std::deque<uint32_t> &FileIds() const;
159     const std::deque<uint32_t> &NodeIndexs() const;
160     const std::deque<uint32_t> &Types() const;
161     const std::deque<uint32_t> &Names() const;
162     const std::deque<uint32_t> &NodeIds() const;
163     const std::deque<uint32_t> &SelfSizes() const;
164     const std::deque<uint32_t> &EdgeCounts() const;
165     const std::deque<uint32_t> &TraceNodeIds() const;
166     const std::deque<uint32_t> &DetachedNess() const;
Clear()167     void Clear() override
168     {
169         CacheBase::Clear();
170         fileIds_.clear();
171         nodeIndexs_.clear();
172         types_.clear();
173         names_.clear();
174         nodeIds_.clear();
175         selfSizes_.clear();
176         edgeCounts_.clear();
177         traceNodeIds_.clear();
178         detachedNess_.clear();
179     }
180 
181 private:
182     std::deque<uint32_t> fileIds_ = {};
183     std::deque<uint32_t> nodeIndexs_ = {};
184     std::deque<uint32_t> types_ = {};
185     std::deque<uint32_t> names_ = {};
186     std::deque<uint32_t> nodeIds_ = {};
187     std::deque<uint32_t> selfSizes_ = {};
188     std::deque<uint32_t> edgeCounts_ = {};
189     std::deque<uint32_t> traceNodeIds_ = {};
190     std::deque<uint32_t> detachedNess_ = {};
191 };
192 
193 class JsHeapSample : public CacheBase {
194 public:
195     size_t AppendNewData(uint32_t fileId, uint64_t timeStampUs, uint32_t lastAssignedId);
196     const std::deque<uint32_t> &FileIds() const;
197     const std::deque<uint64_t> &TimeStampUs() const;
198     const std::deque<uint32_t> &LastAssignedIds() const;
Clear()199     void Clear() override
200     {
201         CacheBase::Clear();
202         fileIds_.clear();
203         timeStampUs_.clear();
204         lastAssignedIds_.clear();
205     }
206 
207 private:
208     std::deque<uint32_t> fileIds_ = {};
209     std::deque<uint64_t> timeStampUs_ = {};
210     std::deque<uint32_t> lastAssignedIds_ = {};
211 };
212 
213 class JsHeapString : public CacheBase {
214 public:
215     size_t AppendNewData(uint32_t fileId, uint32_t fileIndex, std::string string);
216     const std::deque<uint32_t> &FileIds() const;
217     const std::deque<uint64_t> &FileIndexs() const;
218     const std::deque<std::string> &Strings() const;
Clear()219     void Clear() override
220     {
221         CacheBase::Clear();
222         fileIds_.clear();
223         fileIndexs_.clear();
224         strings_.clear();
225     }
226 
227 private:
228     std::deque<uint32_t> fileIds_ = {};
229     std::deque<uint64_t> fileIndexs_ = {};
230     std::deque<std::string> strings_ = {};
231 };
232 
233 struct JsHeapTraceFuncRow {
234     uint32_t fileId = INVALID_UINT32;
235     uint32_t functionIndex = INVALID_UINT32;
236     uint32_t functionId = INVALID_UINT32;
237     uint32_t name = INVALID_UINT32;
238     uint32_t scriptName = INVALID_UINT32;
239     uint32_t scriptId = INVALID_UINT32;
240     uint32_t line = INVALID_UINT32;
241     uint32_t column = INVALID_UINT32;
242 };
243 class JsHeapTraceFuncInfo : public CacheBase {
244 public:
245     size_t AppendNewData(const JsHeapTraceFuncRow &jsHeapTraceFuncRow);
246     const std::deque<uint32_t> &FileIds() const;
247     const std::deque<uint32_t> &FunctionIndexs() const;
248     const std::deque<uint32_t> &FunctionIds() const;
249     const std::deque<uint32_t> &Names() const;
250     const std::deque<uint32_t> &ScriptNames() const;
251     const std::deque<uint32_t> &ScriptIds() const;
252     const std::deque<uint32_t> &Lines() const;
253     const std::deque<uint32_t> &Columns() const;
Clear()254     void Clear() override
255     {
256         CacheBase::Clear();
257         fileIds_.clear();
258         functionIndexs_.clear();
259         functionIds_.clear();
260         names_.clear();
261         scriptNames_.clear();
262         scriptIds_.clear();
263         lines_.clear();
264         columns_.clear();
265     }
266 
267 private:
268     std::deque<uint32_t> fileIds_ = {};
269     std::deque<uint32_t> functionIndexs_ = {};
270     std::deque<uint32_t> functionIds_ = {};
271     std::deque<uint32_t> names_ = {};
272     std::deque<uint32_t> scriptNames_ = {};
273     std::deque<uint32_t> scriptIds_ = {};
274     std::deque<uint32_t> lines_ = {};
275     std::deque<uint32_t> columns_ = {};
276 };
277 struct JsHeapTraceNodeRow {
278     uint32_t fileId = INVALID_UINT32;
279     uint32_t traceNodeId = INVALID_UINT32;
280     uint32_t functionInfoIndex = INVALID_UINT32;
281     uint32_t count = INVALID_UINT32;
282     uint32_t size = INVALID_UINT32;
283     int32_t parentId = INVALID_INT32;
284 };
285 class JsHeapTraceNode : public CacheBase {
286 public:
287     size_t AppendNewData(const JsHeapTraceNodeRow &jsHeapTraceNodeRow);
288     const std::deque<uint32_t> &FileIds() const;
289     const std::deque<uint32_t> &TraceNodeIDs() const;
290     const std::deque<uint32_t> &FunctionInfoIndexs() const;
291     const std::deque<uint32_t> &Counts() const;
292     const std::deque<uint32_t> &NodeSizes() const;
293     const std::deque<int32_t> &ParentIds() const;
Clear()294     void Clear() override
295     {
296         CacheBase::Clear();
297         fileIds_.clear();
298         traceNodeIds_.clear();
299         functionInfoIndexs_.clear();
300         counts_.clear();
301         sizes_.clear();
302         parentIds_.clear();
303     }
304 
305 private:
306     std::deque<uint32_t> fileIds_ = {};
307     std::deque<uint32_t> traceNodeIds_ = {};
308     std::deque<uint32_t> functionInfoIndexs_ = {};
309     std::deque<uint32_t> counts_ = {};
310     std::deque<uint32_t> sizes_ = {};
311     std::deque<int32_t> parentIds_ = {};
312 };
313 struct JsConfigRow {
314     uint32_t pid = INVALID_UINT32;
315     uint64_t type = INVALID_UINT64;
316     uint32_t interval = INVALID_UINT32;
317     uint32_t captureNumericValue = INVALID_UINT32;
318     uint32_t trackAllocation = INVALID_UINT32;
319     uint32_t cpuProfiler = INVALID_UINT32;
320     uint32_t cpuProfilerInterval = INVALID_UINT32;
321 };
322 class JsConfig : public CacheBase {
323 public:
324     size_t AppendNewData(const JsConfigRow &jsConfigRow);
325     const std::deque<uint32_t> &Pids() const;
326     const std::deque<uint64_t> &Types() const;
327     const std::deque<uint32_t> &Intervals() const;
328     const std::deque<uint32_t> &CaptureNumericValue() const;
329     const std::deque<uint32_t> &TrackAllocations() const;
330     const std::deque<uint32_t> &CpuProfiler() const;
331     const std::deque<uint32_t> &CpuProfilerInterval() const;
Clear()332     void Clear() override
333     {
334         CacheBase::Clear();
335         pids_.clear();
336         types_.clear();
337         intervals_.clear();
338         captureNumericValues_.clear();
339         trackAllocations_.clear();
340         cpuProfilers_.clear();
341         cpuProfilerIntervals_.clear();
342     }
343 
344 private:
345     std::deque<uint32_t> pids_ = {};
346     std::deque<uint64_t> types_ = {};
347     std::deque<uint32_t> intervals_ = {};
348     std::deque<uint32_t> captureNumericValues_ = {};
349     std::deque<uint32_t> trackAllocations_ = {};
350     std::deque<uint32_t> cpuProfilers_ = {};
351     std::deque<uint32_t> cpuProfilerIntervals_ = {};
352 };
353 struct JsCpuProfilerNodeRow {
354     uint32_t functionId = INVALID_UINT32;
355     uint32_t functionName = INVALID_UINT32;
356     std::string scriptId = "";
357     uint32_t url = INVALID_UINT32;
358     uint32_t lineNumber = INVALID_UINT32;
359     uint32_t columnNumber = INVALID_UINT32;
360     uint32_t hitCount = INVALID_UINT32;
361     std::string children = "";
362     uint32_t parent = INVALID_UINT32;
363 };
364 class JsCpuProfilerNode : public CacheBase {
365 public:
366     size_t AppendNewData(const JsCpuProfilerNodeRow &jsCpuProfilerNodeRow);
367     const std::deque<uint32_t> &FunctionIds() const;
368     const std::deque<uint32_t> &FunctionNames() const;
369     const std::deque<std::string> &ScriptIds() const;
370     const std::deque<uint32_t> &Urls() const;
371     const std::deque<uint32_t> &LineNumbers() const;
372     const std::deque<int32_t> &ColumnNumbers() const;
373     const std::deque<int32_t> &HitCounts() const;
374     const std::deque<std::string> &Children() const;
375     const std::deque<uint32_t> &Parents() const;
Clear()376     void Clear() override
377     {
378         CacheBase::Clear();
379         functionIds_.clear();
380         functionNames_.clear();
381         scriptIds_.clear();
382         urls_.clear();
383         lineNumbers_.clear();
384         columnNumbers_.clear();
385         hitCounts_.clear();
386         children_.clear();
387         parents_.clear();
388     }
389 
390 private:
391     std::deque<uint32_t> functionIds_ = {};
392     std::deque<uint32_t> functionNames_ = {};
393     std::deque<std::string> scriptIds_ = {};
394     std::deque<uint32_t> urls_ = {};
395     std::deque<uint32_t> lineNumbers_ = {};
396     std::deque<int32_t> columnNumbers_ = {};
397     std::deque<int32_t> hitCounts_ = {};
398     std::deque<std::string> children_ = {};
399     std::deque<uint32_t> parents_ = {};
400 };
401 
402 class JsCpuProfilerSample : public CacheBase {
403 public:
404     size_t AppendNewData(uint32_t functionId, uint64_t startTime, uint64_t endTime, uint64_t dur);
405     const std::deque<uint32_t> &FunctionIds() const;
406     const std::deque<uint64_t> &StartTimes() const;
407     const std::deque<uint64_t> &EndTimes() const;
408     const std::deque<uint64_t> &Durs() const;
Clear()409     void Clear() override
410     {
411         CacheBase::Clear();
412         functionIds_.clear();
413         startTimes_.clear();
414         endTimes_.clear();
415         durs_.clear();
416     }
417 
418 private:
419     std::deque<uint32_t> functionIds_ = {};
420     std::deque<uint64_t> startTimes_ = {};
421     std::deque<uint64_t> endTimes_ = {};
422     std::deque<uint64_t> durs_ = {};
423 };
424 } // namespace TraceStdtype
425 } // namespace SysTuning
426 #endif // ARKTS_STDTYPE_H
427