]> Git Repo - binutils.git/blob - gprofng/src/HeapData.cc
Automatic date update in version.in
[binutils.git] / gprofng / src / HeapData.cc
1 /* Copyright (C) 2021 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 #include "config.h"
22 #include <assert.h>
23 #include <string.h>
24
25 #include "util.h"
26 #include "HeapData.h"
27
28 void
29 HeapData::init ()
30 {
31   allocBytes = 0;
32   leakBytes = 0;
33   allocCnt = 0;
34   leakCnt = 0;
35   stackId = 0;
36   histType = Histable::HEAPCALLSTACK;
37   peakMemUsage = 0;
38   timestamp = 0;
39   pid = 0;
40   userExpId = 0;
41   aSmallestBytes = _10TB;
42   aLargestBytes = 0;
43   a0KB1KBCnt = 0;
44   a1KB8KBCnt = 0;
45   a8KB32KBCnt = 0;
46   a32KB128KBCnt = 0;
47   a128KB256KBCnt = 0;
48   a256KB512KBCnt = 0;
49   a512KB1000KBCnt = 0;
50   a1000KB10MBCnt = 0;
51   a10MB100MBCnt = 0;
52   a100MB1GBCnt = 0;
53   a1GB10GBCnt = 0;
54   a10GB100GBCnt = 0;
55   a100GB1TBCnt = 0;
56   a1TB10TBCnt = 0;
57
58   lSmallestBytes = _10TB;
59   lLargestBytes = 0;
60   l0KB1KBCnt = 0;
61   l1KB8KBCnt = 0;
62   l8KB32KBCnt = 0;
63   l32KB128KBCnt = 0;
64   l128KB256KBCnt = 0;
65   l256KB512KBCnt = 0;
66   l512KB1000KBCnt = 0;
67   l1000KB10MBCnt = 0;
68   l10MB100MBCnt = 0;
69   l100MB1GBCnt = 0;
70   l1GB10GBCnt = 0;
71   l10GB100GBCnt = 0;
72   l100GB1TBCnt = 0;
73   l1TB10TBCnt = 0;
74 }
75
76 HeapData::HeapData (char *sName)
77 {
78   stackName = dbe_strdup (sName);
79   peakStackIds = new Vector<uint64_t>;
80   peakTimestamps = new Vector<hrtime_t>;
81   init ();
82 }
83
84 HeapData::HeapData (HeapData *hData)
85 {
86   stackName = dbe_strdup (hData->stackName);
87   stackId = hData->stackId;
88   histType = hData->histType;
89   allocBytes = hData->allocBytes;
90   leakBytes = hData->leakBytes;
91   allocCnt = hData->allocCnt;
92   leakCnt = hData->leakCnt;
93   peakMemUsage = hData->peakMemUsage;
94   timestamp = hData->timestamp;
95   pid = hData->getPid ();
96   userExpId = hData->getUserExpId ();
97   peakStackIds = new Vector<uint64_t>;
98   Vector<uint64_t> *sIds = hData->peakStackIds;
99   uint64_t sId;
100   if (sIds != NULL)
101     for (int i = 0; i < sIds->size (); i++)
102       {
103         sId = sIds->fetch (i);
104         peakStackIds->append (sId);
105       }
106
107   peakTimestamps = new Vector<hrtime_t>;
108   Vector<hrtime_t> *pts = hData->peakTimestamps;
109   hrtime_t ts;
110   if (pts != NULL)
111     for (int i = 0; i < pts->size (); i++)
112       {
113         ts = pts->fetch (i);
114         peakTimestamps->append (ts);
115       }
116
117   aSmallestBytes = hData->aSmallestBytes;
118   aLargestBytes = hData->aLargestBytes;
119   a0KB1KBCnt = hData->a0KB1KBCnt;
120   a1KB8KBCnt = hData->a1KB8KBCnt;
121   a8KB32KBCnt = hData->a8KB32KBCnt;
122   a32KB128KBCnt = hData->a32KB128KBCnt;
123   a128KB256KBCnt = hData->a128KB256KBCnt;
124   a256KB512KBCnt = hData->a256KB512KBCnt;
125   a512KB1000KBCnt = hData->a512KB1000KBCnt;
126   a1000KB10MBCnt = hData->a1000KB10MBCnt;
127   a10MB100MBCnt = hData->a10MB100MBCnt;
128   a100MB1GBCnt = hData->a100MB1GBCnt;
129   a1GB10GBCnt = hData->a1GB10GBCnt;
130   a10GB100GBCnt = hData->a10GB100GBCnt;
131   a100GB1TBCnt = hData->a100GB1TBCnt;
132   a1TB10TBCnt = hData->a1TB10TBCnt;
133
134   lSmallestBytes = hData->lSmallestBytes;
135   lLargestBytes = hData->lLargestBytes;
136   l0KB1KBCnt = hData->l0KB1KBCnt;
137   l1KB8KBCnt = hData->l1KB8KBCnt;
138   l8KB32KBCnt = hData->l8KB32KBCnt;
139   l32KB128KBCnt = hData->l32KB128KBCnt;
140   l128KB256KBCnt = hData->l128KB256KBCnt;
141   l256KB512KBCnt = hData->l256KB512KBCnt;
142   l512KB1000KBCnt = hData->l512KB1000KBCnt;
143   l1000KB10MBCnt = hData->l1000KB10MBCnt;
144   l10MB100MBCnt = hData->l10MB100MBCnt;
145   l100MB1GBCnt = hData->l100MB1GBCnt;
146   l1GB10GBCnt = hData->l1GB10GBCnt;
147   l10GB100GBCnt = hData->l10GB100GBCnt;
148   l100GB1TBCnt = hData->l100GB1TBCnt;
149   l1TB10TBCnt = hData->l1TB10TBCnt;
150 }
151
152 HeapData::~HeapData ()
153 {
154   free (stackName);
155   delete peakStackIds;
156   delete peakTimestamps;
157 }
158
159 Histable*
160 HeapData::convertto (Histable_type type, Histable*)
161 {
162   return type == histType ? this : NULL;
163 }
164
165 char*
166 HeapData::get_name (Histable::NameFormat /*_nfmt*/)
167 {
168   return stackName;
169 }
170
171 char*
172 HeapData::get_raw_name (Histable::NameFormat /*_nfmt*/)
173 {
174   return stackName;
175 }
176
177 void
178 HeapData::set_name (char* _name)
179 {
180   free (stackName);
181   stackName = dbe_strdup (_name);
182 }
183
184 void
185 HeapData::setPeakMemUsage (int64_t pmu, uint64_t sId, hrtime_t ts, int procId, int uei)
186 {
187   if (peakMemUsage < pmu)
188     {
189       peakMemUsage = pmu;
190       peakStackIds->reset ();
191       peakStackIds->append (sId);
192       peakTimestamps->reset ();
193       peakTimestamps->append (ts);
194       pid = procId;
195       userExpId = uei;
196     }
197   else if (peakMemUsage == pmu)
198     {
199       for (int i = 0; i < peakStackIds->size (); i++)
200         {
201           uint64_t curSId = peakStackIds->fetch (i);
202           if (curSId == sId)
203             return;
204         }
205       peakStackIds->append (sId);
206       peakTimestamps->append (ts);
207       pid = procId;
208       userExpId = uei;
209     }
210 }
211
212 void
213 HeapData::setAllocStat (int64_t nb)
214 {
215   if (aSmallestBytes > nb)
216     aSmallestBytes = nb;
217   if (aLargestBytes < nb)
218     aLargestBytes = nb;
219   if (nb >= 0 && nb <= _1KB)
220     a0KB1KBCnt++;
221   else if (nb <= _8KB)
222     a1KB8KBCnt++;
223   else if (nb <= _32KB)
224     a8KB32KBCnt++;
225   else if (nb <= _128KB)
226     a32KB128KBCnt++;
227   else if (nb <= _256KB)
228     a128KB256KBCnt++;
229   else if (nb <= _512KB)
230     a256KB512KBCnt++;
231   else if (nb <= _1000KB)
232     a512KB1000KBCnt++;
233   else if (nb <= _10MB)
234     a1000KB10MBCnt++;
235   else if (nb <= _100MB)
236     a10MB100MBCnt++;
237   else if (nb <= _1GB)
238     a100MB1GBCnt++;
239   else if (nb <= _10GB)
240     a1GB10GBCnt++;
241   else if (nb <= _100GB)
242     a10GB100GBCnt++;
243   else if (nb <= _1TB)
244     a100GB1TBCnt++;
245   else if (nb <= _10TB)
246     a1TB10TBCnt++;
247 }
248
249 void
250 HeapData::setLeakStat (int64_t nb)
251 {
252   if (lSmallestBytes > nb)
253     lSmallestBytes = nb;
254   if (lLargestBytes < nb)
255     lLargestBytes = nb;
256   if (nb >= 0 && nb <= _1KB)
257     l0KB1KBCnt++;
258   else if (nb <= _8KB)
259     l1KB8KBCnt++;
260   else if (nb <= _32KB)
261     l8KB32KBCnt++;
262   else if (nb <= _128KB)
263     l32KB128KBCnt++;
264   else if (nb <= _256KB)
265     l128KB256KBCnt++;
266   else if (nb <= _512KB)
267     l256KB512KBCnt++;
268   else if (nb <= _1000KB)
269     l512KB1000KBCnt++;
270   else if (nb <= _10MB)
271     l1000KB10MBCnt++;
272   else if (nb <= _100MB)
273     l10MB100MBCnt++;
274   else if (nb <= _1GB)
275     l100MB1GBCnt++;
276   else if (nb <= _10GB)
277     l1GB10GBCnt++;
278   else if (nb <= _100GB)
279     l10GB100GBCnt++;
280   else if (nb <= _1TB)
281     l100GB1TBCnt++;
282   else if (nb <= _10TB)
283     l1TB10TBCnt++;
284 }
This page took 0.03752 seconds and 4 git commands to generate.