| /* Copyright (C) 2021-2023 Free Software Foundation, Inc. |
| Contributed by Oracle. |
| |
| This file is part of GNU Binutils. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #include "config.h" |
| #include <assert.h> |
| #include <string.h> |
| |
| #include "util.h" |
| #include "HeapData.h" |
| |
| void |
| HeapData::init () |
| { |
| allocBytes = 0; |
| leakBytes = 0; |
| allocCnt = 0; |
| leakCnt = 0; |
| stackId = 0; |
| histType = Histable::HEAPCALLSTACK; |
| peakMemUsage = 0; |
| timestamp = 0; |
| pid = 0; |
| userExpId = 0; |
| aSmallestBytes = _10TB; |
| aLargestBytes = 0; |
| a0KB1KBCnt = 0; |
| a1KB8KBCnt = 0; |
| a8KB32KBCnt = 0; |
| a32KB128KBCnt = 0; |
| a128KB256KBCnt = 0; |
| a256KB512KBCnt = 0; |
| a512KB1000KBCnt = 0; |
| a1000KB10MBCnt = 0; |
| a10MB100MBCnt = 0; |
| a100MB1GBCnt = 0; |
| a1GB10GBCnt = 0; |
| a10GB100GBCnt = 0; |
| a100GB1TBCnt = 0; |
| a1TB10TBCnt = 0; |
| |
| lSmallestBytes = _10TB; |
| lLargestBytes = 0; |
| l0KB1KBCnt = 0; |
| l1KB8KBCnt = 0; |
| l8KB32KBCnt = 0; |
| l32KB128KBCnt = 0; |
| l128KB256KBCnt = 0; |
| l256KB512KBCnt = 0; |
| l512KB1000KBCnt = 0; |
| l1000KB10MBCnt = 0; |
| l10MB100MBCnt = 0; |
| l100MB1GBCnt = 0; |
| l1GB10GBCnt = 0; |
| l10GB100GBCnt = 0; |
| l100GB1TBCnt = 0; |
| l1TB10TBCnt = 0; |
| } |
| |
| HeapData::HeapData (char *sName) |
| { |
| stackName = dbe_strdup (sName); |
| peakStackIds = new Vector<uint64_t>; |
| peakTimestamps = new Vector<hrtime_t>; |
| init (); |
| } |
| |
| HeapData::HeapData (HeapData *hData) |
| { |
| stackName = dbe_strdup (hData->stackName); |
| stackId = hData->stackId; |
| histType = hData->histType; |
| allocBytes = hData->allocBytes; |
| leakBytes = hData->leakBytes; |
| allocCnt = hData->allocCnt; |
| leakCnt = hData->leakCnt; |
| peakMemUsage = hData->peakMemUsage; |
| timestamp = hData->timestamp; |
| pid = hData->getPid (); |
| userExpId = hData->getUserExpId (); |
| peakStackIds = new Vector<uint64_t>; |
| Vector<uint64_t> *sIds = hData->peakStackIds; |
| uint64_t sId; |
| if (sIds != NULL) |
| for (int i = 0; i < sIds->size (); i++) |
| { |
| sId = sIds->fetch (i); |
| peakStackIds->append (sId); |
| } |
| |
| peakTimestamps = new Vector<hrtime_t>; |
| Vector<hrtime_t> *pts = hData->peakTimestamps; |
| hrtime_t ts; |
| if (pts != NULL) |
| for (int i = 0; i < pts->size (); i++) |
| { |
| ts = pts->fetch (i); |
| peakTimestamps->append (ts); |
| } |
| |
| aSmallestBytes = hData->aSmallestBytes; |
| aLargestBytes = hData->aLargestBytes; |
| a0KB1KBCnt = hData->a0KB1KBCnt; |
| a1KB8KBCnt = hData->a1KB8KBCnt; |
| a8KB32KBCnt = hData->a8KB32KBCnt; |
| a32KB128KBCnt = hData->a32KB128KBCnt; |
| a128KB256KBCnt = hData->a128KB256KBCnt; |
| a256KB512KBCnt = hData->a256KB512KBCnt; |
| a512KB1000KBCnt = hData->a512KB1000KBCnt; |
| a1000KB10MBCnt = hData->a1000KB10MBCnt; |
| a10MB100MBCnt = hData->a10MB100MBCnt; |
| a100MB1GBCnt = hData->a100MB1GBCnt; |
| a1GB10GBCnt = hData->a1GB10GBCnt; |
| a10GB100GBCnt = hData->a10GB100GBCnt; |
| a100GB1TBCnt = hData->a100GB1TBCnt; |
| a1TB10TBCnt = hData->a1TB10TBCnt; |
| |
| lSmallestBytes = hData->lSmallestBytes; |
| lLargestBytes = hData->lLargestBytes; |
| l0KB1KBCnt = hData->l0KB1KBCnt; |
| l1KB8KBCnt = hData->l1KB8KBCnt; |
| l8KB32KBCnt = hData->l8KB32KBCnt; |
| l32KB128KBCnt = hData->l32KB128KBCnt; |
| l128KB256KBCnt = hData->l128KB256KBCnt; |
| l256KB512KBCnt = hData->l256KB512KBCnt; |
| l512KB1000KBCnt = hData->l512KB1000KBCnt; |
| l1000KB10MBCnt = hData->l1000KB10MBCnt; |
| l10MB100MBCnt = hData->l10MB100MBCnt; |
| l100MB1GBCnt = hData->l100MB1GBCnt; |
| l1GB10GBCnt = hData->l1GB10GBCnt; |
| l10GB100GBCnt = hData->l10GB100GBCnt; |
| l100GB1TBCnt = hData->l100GB1TBCnt; |
| l1TB10TBCnt = hData->l1TB10TBCnt; |
| } |
| |
| HeapData::~HeapData () |
| { |
| free (stackName); |
| delete peakStackIds; |
| delete peakTimestamps; |
| } |
| |
| Histable* |
| HeapData::convertto (Histable_type type, Histable*) |
| { |
| return type == histType ? this : NULL; |
| } |
| |
| char* |
| HeapData::get_name (Histable::NameFormat /*_nfmt*/) |
| { |
| return stackName; |
| } |
| |
| char* |
| HeapData::get_raw_name (Histable::NameFormat /*_nfmt*/) |
| { |
| return stackName; |
| } |
| |
| void |
| HeapData::set_name (char* _name) |
| { |
| free (stackName); |
| stackName = dbe_strdup (_name); |
| } |
| |
| void |
| HeapData::setPeakMemUsage (int64_t pmu, uint64_t sId, hrtime_t ts, int procId, int uei) |
| { |
| if (peakMemUsage < pmu) |
| { |
| peakMemUsage = pmu; |
| peakStackIds->reset (); |
| peakStackIds->append (sId); |
| peakTimestamps->reset (); |
| peakTimestamps->append (ts); |
| pid = procId; |
| userExpId = uei; |
| } |
| else if (peakMemUsage == pmu) |
| { |
| for (int i = 0; i < peakStackIds->size (); i++) |
| { |
| uint64_t curSId = peakStackIds->fetch (i); |
| if (curSId == sId) |
| return; |
| } |
| peakStackIds->append (sId); |
| peakTimestamps->append (ts); |
| pid = procId; |
| userExpId = uei; |
| } |
| } |
| |
| void |
| HeapData::setAllocStat (int64_t nb) |
| { |
| if (aSmallestBytes > nb) |
| aSmallestBytes = nb; |
| if (aLargestBytes < nb) |
| aLargestBytes = nb; |
| if (nb >= 0 && nb <= _1KB) |
| a0KB1KBCnt++; |
| else if (nb <= _8KB) |
| a1KB8KBCnt++; |
| else if (nb <= _32KB) |
| a8KB32KBCnt++; |
| else if (nb <= _128KB) |
| a32KB128KBCnt++; |
| else if (nb <= _256KB) |
| a128KB256KBCnt++; |
| else if (nb <= _512KB) |
| a256KB512KBCnt++; |
| else if (nb <= _1000KB) |
| a512KB1000KBCnt++; |
| else if (nb <= _10MB) |
| a1000KB10MBCnt++; |
| else if (nb <= _100MB) |
| a10MB100MBCnt++; |
| else if (nb <= _1GB) |
| a100MB1GBCnt++; |
| else if (nb <= _10GB) |
| a1GB10GBCnt++; |
| else if (nb <= _100GB) |
| a10GB100GBCnt++; |
| else if (nb <= _1TB) |
| a100GB1TBCnt++; |
| else if (nb <= _10TB) |
| a1TB10TBCnt++; |
| } |
| |
| void |
| HeapData::setLeakStat (int64_t nb) |
| { |
| if (lSmallestBytes > nb) |
| lSmallestBytes = nb; |
| if (lLargestBytes < nb) |
| lLargestBytes = nb; |
| if (nb >= 0 && nb <= _1KB) |
| l0KB1KBCnt++; |
| else if (nb <= _8KB) |
| l1KB8KBCnt++; |
| else if (nb <= _32KB) |
| l8KB32KBCnt++; |
| else if (nb <= _128KB) |
| l32KB128KBCnt++; |
| else if (nb <= _256KB) |
| l128KB256KBCnt++; |
| else if (nb <= _512KB) |
| l256KB512KBCnt++; |
| else if (nb <= _1000KB) |
| l512KB1000KBCnt++; |
| else if (nb <= _10MB) |
| l1000KB10MBCnt++; |
| else if (nb <= _100MB) |
| l10MB100MBCnt++; |
| else if (nb <= _1GB) |
| l100MB1GBCnt++; |
| else if (nb <= _10GB) |
| l1GB10GBCnt++; |
| else if (nb <= _100GB) |
| l10GB100GBCnt++; |
| else if (nb <= _1TB) |
| l100GB1TBCnt++; |
| else if (nb <= _10TB) |
| l1TB10TBCnt++; |
| } |