1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #ifndef _HEAPDATA_H
22 #define _HEAPDATA_H
23
24 #include "gp-defs.h"
25 #include "gp-time.h"
26
27 #include "vec.h"
28 #include "data_pckts.h"
29 #include "Histable.h"
30
31 #define TOTAL_HEAPNAME NTXT("<Total>")
32 #define TOTAL_STACK_ID 0
33 #define _1KB 1024
34 #define _8KB 8192
35 #define _32KB 32768
36 #define _128KB 131072
37 #define _256KB 262144
38 #define _512KB 524288
39 #define _1000KB 1048576
40 #define _10MB 10485760
41 #define _100MB 104857600
42 #define _1GB 1073741824
43 #define _10GB 10737418240
44 #define _100GB 107374182400
45 #define _1TB 1099511627776
46 #define _10TB 10995116277760
47
48 class HeapData : public Histable
49 {
50 friend class HeapActivity;
51 public:
52 HeapData (char *sName);
53 HeapData (HeapData *hData);
54 ~HeapData ();
55 char *get_raw_name (Histable::NameFormat nfmt);
56 void init ();
57 void setStackName (char* sName);
58 void setPeakMemUsage (int64_t pmu, uint64_t sId, hrtime_t ts, int procId, int uei);
59
60 virtual char *get_name (Histable::NameFormat nfmt);
61 virtual void set_name (char * _name);
62 virtual Histable *convertto (Histable_type, Histable* = NULL);
63
64 virtual Histable_type
65 get_type ()
66 {
67 return histType;
68 }
69
70 virtual uint64_t
71 get_addr ()
72 {
73 return stackId;
74 }
75
76 uint64_t
77 get_index ()
78 {
79 return stackId;
80 }
81
82 char *
83 getStackName ()
84 {
85 return stackName;
86 }
87
88 void
89 addAllocEvent (uint64_t nb)
90 {
91 allocBytes += nb;
92 allocCnt++;
93 }
94
95 uint64_t
96 getAllocBytes ()
97 {
98 return allocBytes;
99 }
100
101 int32_t
102 getAllocCnt ()
103 {
104 return allocCnt;
105 }
106
107 void
108 addLeakEvent (uint64_t nb)
109 {
110 leakBytes += nb;
111 leakCnt++;
112 }
113
114 uint64_t
115 getLeakBytes ()
116 {
117 return leakBytes;
118 }
119
120 int32_t
121 getLeakCnt ()
122 {
123 return leakCnt;
124 }
125
126 void
127 setStackId (uint64_t sId)
128 {
129 stackId = sId;
130 }
131
132 uint64_t
133 getStackId ()
134 {
135 return stackId;
136 }
137
138 void
139 setTimestamp (hrtime_t ts)
140 {
141 timestamp = ts;
142 }
143
144 hrtime_t
145 getTimestamp ()
146 {
147 return timestamp;
148 }
149
150 void
151 setHistType (Histable::Type hType)
152 {
153 histType = hType;
154 }
155
156 Histable::Type
157 getHistType ()
158 {
159 return histType;
160 }
161
162 int64_t
163 getPeakMemUsage ()
164 {
165 return peakMemUsage;
166 }
167
168 Vector<uint64_t> *
169 getPeakStackIds ()
170 {
171 return peakStackIds;
172 }
173
174 Vector<hrtime_t> *
175 getPeakTimestamps ()
176 {
177 return peakTimestamps;
178 }
179
180 void
181 setPid (int procId)
182 {
183 pid = procId;
184 }
185
186 int
187 getPid ()
188 {
189 return pid;
190 }
191
192 void
193 setUserExpId (int uei)
194 {
195 userExpId = uei;
196 }
197
198 int
199 getUserExpId ()
200 {
201 return userExpId;
202 }
203
204 void setAllocStat (int64_t nb);
205
206 int64_t
207 getASmallestBytes ()
208 {
209 return aSmallestBytes;
210 }
211
212 int64_t
213 getALargestBytes ()
214 {
215 return aLargestBytes;
216 }
217
218 int32_t
219 getA0KB1KBCnt ()
220 {
221 return a0KB1KBCnt;
222 }
223
224 int32_t
225 getA1KB8KBCnt ()
226 {
227 return a1KB8KBCnt;
228 }
229
230 int32_t
231 getA8KB32KBCnt ()
232 {
233 return a8KB32KBCnt;
234 }
235
236 int32_t
237 getA32KB128KBCnt ()
238 {
239 return a32KB128KBCnt;
240 }
241
242 int32_t
243 getA128KB256KBCnt ()
244 {
245 return a128KB256KBCnt;
246 }
247
248 int32_t
249 getA256KB512KBCnt ()
250 {
251 return a256KB512KBCnt;
252 }
253
254 int32_t
255 getA512KB1000KBCnt ()
256 {
257 return a512KB1000KBCnt;
258 }
259
260 int32_t
261 getA1000KB10MBCnt ()
262 {
263 return a1000KB10MBCnt;
264 }
265
266 int32_t
267 getA10MB100MBCnt ()
268 {
269 return a10MB100MBCnt;
270 }
271
272 int32_t
273 getA100MB1GBCnt ()
274 {
275 return a100MB1GBCnt;
276 }
277
278 int32_t
279 getA1GB10GBCnt ()
280 {
281 return a1GB10GBCnt;
282 }
283
284 int32_t
285 getA10GB100GBCnt ()
286 {
287 return a10GB100GBCnt;
288 }
289
290 int32_t
291 getA100GB1TBCnt ()
292 {
293 return a100GB1TBCnt;
294 }
295
296 int32_t
297 getA1TB10TBCnt ()
298 {
299 return a1TB10TBCnt;
300 }
301
302 void setLeakStat (int64_t nb);
303
304 int64_t
305 getLSmallestBytes ()
306 {
307 return lSmallestBytes;
308 }
309
310 int64_t
311 getLLargestBytes ()
312 {
313 return lLargestBytes;
314 }
315
316 int32_t
317 getL0KB1KBCnt ()
318 {
319 return l0KB1KBCnt;
320 }
321
322 int32_t
323 getL1KB8KBCnt ()
324 {
325 return l1KB8KBCnt;
326 }
327
328 int32_t
329 getL8KB32KBCnt ()
330 {
331 return l8KB32KBCnt;
332 }
333
334 int32_t
335 getL32KB128KBCnt ()
336 {
337 return l32KB128KBCnt;
338 }
339
340 int32_t
341 getL128KB256KBCnt ()
342 {
343 return l128KB256KBCnt;
344 }
345
346 int32_t
347 getL256KB512KBCnt ()
348 {
349 return l256KB512KBCnt;
350 }
351
352 int32_t
353 getL512KB1000KBCnt ()
354 {
355 return l512KB1000KBCnt;
356 }
357
358 int32_t
359 getL1000KB10MBCnt ()
360 {
361 return l1000KB10MBCnt;
362 }
363
364 int32_t
365 getL10MB100MBCnt ()
366 {
367 return l10MB100MBCnt;
368 }
369
370 int32_t
371 getL100MB1GBCnt ()
372 {
373 return l100MB1GBCnt;
374 }
375
376 int32_t
377 getL1GB10GBCnt ()
378 {
379 return l1GB10GBCnt;
380 }
381
382 int32_t
383 getL10GB100GBCnt ()
384 {
385 return l10GB100GBCnt;
386 }
387
388 int32_t
389 getL100GB1TBCnt ()
390 {
391 return l100GB1TBCnt;
392 }
393
394 int32_t
395 getL1TB10TBCnt ()
396 {
397 return l1TB10TBCnt;
398 }
399
400 private:
401 char *stackName; // stack name
402 uint64_t allocBytes; // The total bytes allocated
403 uint64_t leakBytes; // The total bytes leaked
404 int32_t allocCnt; // The alloc count
405 int32_t leakCnt; // The leak count
406 Histable::Type histType; // The Histable type: HEAPCALLSTACK
407 int64_t peakMemUsage; // Keep track of peak memory usage
408 uint64_t stackId;
409 Vector<uint64_t> *peakStackIds; // The peak memory usage stack ids
410 hrtime_t timestamp;
411 Vector<hrtime_t> *peakTimestamps; // The peak data
412 int pid; // The process id
413 int userExpId; // The experiment id
414
415 int64_t aSmallestBytes;
416 int64_t aLargestBytes;
417 int32_t a0KB1KBCnt;
418 int32_t a1KB8KBCnt;
419 int32_t a8KB32KBCnt;
420 int32_t a32KB128KBCnt;
421 int32_t a128KB256KBCnt;
422 int32_t a256KB512KBCnt;
423 int32_t a512KB1000KBCnt;
424 int32_t a1000KB10MBCnt;
425 int32_t a10MB100MBCnt;
426 int32_t a100MB1GBCnt;
427 int32_t a1GB10GBCnt;
428 int32_t a10GB100GBCnt;
429 int32_t a100GB1TBCnt;
430 int32_t a1TB10TBCnt;
431
432 int64_t lSmallestBytes;
433 int64_t lLargestBytes;
434 int32_t l0KB1KBCnt;
435 int32_t l1KB8KBCnt;
436 int32_t l8KB32KBCnt;
437 int32_t l32KB128KBCnt;
438 int32_t l128KB256KBCnt;
439 int32_t l256KB512KBCnt;
440 int32_t l512KB1000KBCnt;
441 int32_t l1000KB10MBCnt;
442 int32_t l10MB100MBCnt;
443 int32_t l100MB1GBCnt;
444 int32_t l1GB10GBCnt;
445 int32_t l10GB100GBCnt;
446 int32_t l100GB1TBCnt;
447 int32_t l1TB10TBCnt;
448 };
449
450 #endif