diff options
Diffstat (limited to 'gprofng/src/FileData.cc')
| -rw-r--r-- | gprofng/src/FileData.cc | 400 |
1 files changed, 400 insertions, 0 deletions
diff --git a/gprofng/src/FileData.cc b/gprofng/src/FileData.cc new file mode 100644 index 0000000..7a941f5 --- /dev/null +++ b/gprofng/src/FileData.cc @@ -0,0 +1,400 @@ +/* Copyright (C) 2021 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 "FileData.h" + +void +FileData::init () +{ + readTime = 0; + writeTime = 0; + otherTime = 0; + errorTime = 0; + readBytes = 0; + writeBytes = 0; + readCnt = 0; + writeCnt = 0; + otherCnt = 0; + errorCnt = 0; + wSlowestBytes = 0; + wSmallestBytes = _10TB; + wLargestBytes = 0; + w0KB1KBCnt = 0; + w1KB8KBCnt = 0; + w8KB32KBCnt = 0; + w32KB128KBCnt = 0; + w128KB256KBCnt = 0; + w256KB512KBCnt = 0; + w512KB1000KBCnt = 0; + w1000KB10MBCnt = 0; + w10MB100MBCnt = 0; + w100MB1GBCnt = 0; + w1GB10GBCnt = 0; + w10GB100GBCnt = 0; + w100GB1TBCnt = 0; + w1TB10TBCnt = 0; + rSlowestBytes = 0; + rSmallestBytes = _10TB; + rLargestBytes = 0; + r0KB1KBCnt = 0; + r1KB8KBCnt = 0; + r8KB32KBCnt = 0; + r32KB128KBCnt = 0; + r128KB256KBCnt = 0; + r256KB512KBCnt = 0; + r512KB1000KBCnt = 0; + r1000KB10MBCnt = 0; + r10MB100MBCnt = 0; + r100MB1GBCnt = 0; + r1GB10GBCnt = 0; + r10GB100GBCnt = 0; + r100GB1TBCnt = 0; + r1TB10TBCnt = 0; +} + +FileData::FileData (const char *fName) +{ + fileName = dbe_strdup (fName); + fileDesList = new Vector<int>; + virtualFds = new Vector<int64_t>; + virtualFd = -1; + fileDes = -1; + fsType[0] = '\0'; + histType = Histable::IOACTVFD; + init (); +} + +FileData::FileData (FileData *fData) +{ + fileName = dbe_strdup (fData->fileName); + fileDesList = new Vector<int>; + Vector<int> *fdList = fData->fileDesList; + int fd; + if (fdList != NULL) + for (int i = 0; i < fdList->size (); i++) + if ((fd = fdList->fetch (i)) == -1) + fileDesList->append (fd); + + virtualFds = new Vector<int64_t>; + Vector<int64_t> *vfds = fData->virtualFds; + int64_t vfd; + if (vfds != NULL) + for (int i = 0; i < vfds->size (); i++) + if ((vfd = vfds->fetch (i)) == -1) + virtualFds->append (vfd); + virtualFd = fData->virtualFd; + fileDes = fData->fileDes; + histType = fData->histType; + + for (int i = 0; i < FSTYPESZ; i++) + fsType[i] = fData->fsType[i]; + + readTime = fData->readTime; + writeTime = fData->writeTime; + otherTime = fData->otherTime; + errorTime = fData->errorTime; + readBytes = fData->readBytes; + writeBytes = fData->writeBytes; + readCnt = fData->readCnt; + writeCnt = fData->writeCnt; + otherCnt = fData->otherCnt; + errorCnt = fData->errorCnt; + wSlowestBytes = fData->wSlowestBytes; + wSmallestBytes = fData->wSmallestBytes; + wLargestBytes = fData->wLargestBytes; + w0KB1KBCnt = fData->w0KB1KBCnt; + w1KB8KBCnt = fData->w1KB8KBCnt; + w8KB32KBCnt = fData->w8KB32KBCnt; + w32KB128KBCnt = fData->w32KB128KBCnt; + w128KB256KBCnt = fData->w128KB256KBCnt; + w256KB512KBCnt = fData->w256KB512KBCnt; + w512KB1000KBCnt = fData->w512KB1000KBCnt; + w1000KB10MBCnt = fData->w1000KB10MBCnt; + w10MB100MBCnt = fData->w10MB100MBCnt; + w100MB1GBCnt = fData->w100MB1GBCnt; + w1GB10GBCnt = fData->w1GB10GBCnt; + w10GB100GBCnt = fData->w10GB100GBCnt; + w100GB1TBCnt = fData->w100GB1TBCnt; + w1TB10TBCnt = fData->w1TB10TBCnt; + rSlowestBytes = fData->rSlowestBytes; + rSmallestBytes = fData->rSmallestBytes; + rLargestBytes = fData->rLargestBytes; + r0KB1KBCnt = fData->r0KB1KBCnt; + r1KB8KBCnt = fData->r1KB8KBCnt; + r8KB32KBCnt = fData->r8KB32KBCnt; + r32KB128KBCnt = fData->r32KB128KBCnt; + r128KB256KBCnt = fData->r128KB256KBCnt; + r256KB512KBCnt = fData->r256KB512KBCnt; + r512KB1000KBCnt = fData->r512KB1000KBCnt; + r1000KB10MBCnt = fData->r1000KB10MBCnt; + r10MB100MBCnt = fData->r10MB100MBCnt; + r100MB1GBCnt = fData->r100MB1GBCnt; + r1GB10GBCnt = fData->r1GB10GBCnt; + r10GB100GBCnt = fData->r10GB100GBCnt; + r100GB1TBCnt = fData->r100GB1TBCnt; + r1TB10TBCnt = fData->r1TB10TBCnt; +} + +FileData::~FileData () +{ + free (fileName); + delete fileDesList; + delete virtualFds; +} + +void +FileData::setVirtualFds (int64_t vfd) +{ + for (int i = 0; i < virtualFds->size (); i++) + if (vfd == virtualFds->fetch (i)) + return; + virtualFds->append (vfd); +} + +void +FileData::setFileDesList (int fd) +{ + for (int i = 0; i < fileDesList->size (); i++) + if (fd == fileDesList->fetch (i)) + return; + fileDesList->append (fd); +} + +void +FileData::setFsType (const char* fst) +{ + size_t len = strlen (fst); + if (len > 0 && len < FSTYPESZ) + snprintf (fsType, sizeof (fsType), NTXT ("%s"), fst); + else + snprintf (fsType, sizeof (fsType), GTXT ("error")); +} + +Histable* +FileData::convertto (Histable_type type, Histable*) +{ + return (type == histType ? this : NULL); +} + +char* +FileData::get_name (Histable::NameFormat /*_nfmt*/) +{ + if (histType == Histable::IOACTVFD) + { + if (!streq (fileName, NTXT ("<Total>"))) + { + if (fileDes >= 0) + return dbe_sprintf (GTXT ("%s (IOVFD=%lld, FD=%d)"), fileName, + (long long) virtualFd, (int) fileDes); + return dbe_sprintf (GTXT ("%s (IOVFD=%lld)"), fileName, + (long long) virtualFd); + } + else + return fileName; + } + else if (histType == Histable::IOACTFILE) + { + if (!streq (fileName, NTXT ("<Total>"))) + { + if (!streq (fsType, NTXT ("N/A"))) + return dbe_sprintf (GTXT ("%s (FS=%s)"), fileName, fsType); + return fileName; + } + return fileName; + } + return fileName; +} + +char* +FileData::get_raw_name (Histable::NameFormat /*_nfmt*/) +{ + return fileName; +} + +void +FileData::setFsType (FileSystem_type fst) +{ + const char *fsName; + switch (fst) + { + case ZFS_TYPE: + fsName = "zfs"; + break; + case NFS_TYPE: + fsName = "nfs"; + break; + case UFS_TYPE: + fsName = "ufs"; + break; + case UDFS_TYPE: + fsName = "udfs"; + break; + case LOFS_TYPE: + fsName = "lofs"; + break; + case VXFS_TYPE: + fsName = "vxfs"; + break; + case TMPFS_TYPE: + fsName = "tmpfs"; + break; + case PCFS_TYPE: + fsName = "pcfs"; + break; + case HSFS_TYPE: + fsName = "hsfs"; + break; + case PROCFS_TYPE: + fsName = "procfs"; + break; + case FIFOFS_TYPE: + fsName = "fifofs"; + break; + case SWAPFS_TYPE: + fsName = "swapfs"; + break; + case CACHEFS_TYPE: + fsName = "cachefs"; + break; + case AUTOFS_TYPE: + fsName = "autofs"; + break; + case SPECFS_TYPE: + fsName = "specfs"; + break; + case SOCKFS_TYPE: + fsName = "sockfs"; + break; + case FDFS_TYPE: + fsName = "fdfs"; + break; + case MNTFS_TYPE: + fsName = "mntfs"; + break; + case NAMEFS_TYPE: + fsName = "namefs"; + break; + case OBJFS_TYPE: + fsName = "objfs"; + break; + case SHAREFS_TYPE: + fsName = "sharefs"; + break; + case EXT2FS_TYPE: + fsName = "ext2"; + break; + case EXT3FS_TYPE: + fsName = "ext3"; + break; + case EXT4FS_TYPE: + fsName = "ext4"; + break; + case UNKNOWNFS_TYPE: + fsName = "N/A"; + break; + default: + fsName = "N/A"; + break; + } + setFsType (fsName); +} + +void +FileData::setWriteStat (hrtime_t wt, int64_t nb) +{ + if (wSlowestBytes < wt) + wSlowestBytes = wt; + if (nb != 0 && wSmallestBytes > nb) + wSmallestBytes = nb; + if (wLargestBytes < nb) + wLargestBytes = nb; + if (nb >= 0 && nb <= _1KB) + w0KB1KBCnt++; + else if (nb <= _8KB) + w1KB8KBCnt++; + else if (nb <= _32KB) + w8KB32KBCnt++; + else if (nb <= _128KB) + w32KB128KBCnt++; + else if (nb <= _256KB) + w128KB256KBCnt++; + else if (nb <= _512KB) + w256KB512KBCnt++; + else if (nb <= _1000KB) + w512KB1000KBCnt++; + else if (nb <= _10MB) + w1000KB10MBCnt++; + else if (nb <= _100MB) + w10MB100MBCnt++; + else if (nb <= _1GB) + w100MB1GBCnt++; + else if (nb <= _10GB) + w1GB10GBCnt++; + else if (nb <= _100GB) + w10GB100GBCnt++; + else if (nb <= _1TB) + w100GB1TBCnt++; + else if (nb <= _10TB) + w1TB10TBCnt++; +} + +void +FileData::setReadStat (hrtime_t rt, int64_t nb) +{ + if (rSlowestBytes < rt) + rSlowestBytes = rt; + if (nb != 0 && rSmallestBytes > nb) + rSmallestBytes = nb; + if (rLargestBytes < nb) + rLargestBytes = nb; + if (nb >= 0 && nb <= _1KB) + r0KB1KBCnt++; + else if (nb <= _8KB) + r1KB8KBCnt++; + else if (nb <= _32KB) + r8KB32KBCnt++; + else if (nb <= _128KB) + r32KB128KBCnt++; + else if (nb <= _256KB) + r128KB256KBCnt++; + else if (nb <= _512KB) + r256KB512KBCnt++; + else if (nb <= _1000KB) + r512KB1000KBCnt++; + else if (nb <= _10MB) + r1000KB10MBCnt++; + else if (nb <= _100MB) + r10MB100MBCnt++; + else if (nb <= _1GB) + r100MB1GBCnt++; + else if (nb <= _10GB) + r1GB10GBCnt++; + else if (nb <= _100GB) + r10GB100GBCnt++; + else if (nb <= _1TB) + r100GB1TBCnt++; + else if (nb <= _10TB) + r1TB10TBCnt++; +} |