gprofng/src/FileData.cc - binutils-gdb - Git at Google

 /* 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 "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++;
 }
	/* 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 "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++;
	}