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