derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

base-stats,misc: Rename Stats namespace as statistics

Browse Source 
As part of recent decisions regarding namespace
naming conventions, all namespaces will be changed
to snake case.

::Stats became ::statistics.

"statistics" was chosen over "stats" to avoid generating
conflicts with the already existing variables (there are
way too many "stats" in the codebase), which would make
this patch even more disturbing for the users.

Change-Id: If877b12d7dac356f86e3b3d941bf7558a4fd8719
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/45421
Reviewed-by: Jason Lowe-Power <power.jg@gmail.com>
Maintainer: Jason Lowe-Power <power.jg@gmail.com>
Tested-by: kokoro <noreply+kokoro@google.com>
This commit is contained in:
Daniel R. Carvalho
2021-05-06 20:00:51 -03:00
committed by Daniel Carvalho
parent fa505f1c23
commit 98ac080ec4
228 changed files with 3078 additions and 2970 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/dev/arm/flash_device.cc
View File

@@ -455,23 +455,22 @@ FlashDevice::getUnknownPages(uint32_t index)
return unknownPages[index >> 5] & (0x01 << (index % 32));
}
FlashDevice::
FlashDeviceStats::FlashDeviceStats(Stats::Group *parent)
: Stats::Group(parent, "FlashDevice"),
ADD_STAT(totalGCActivations, Stats::units::Count::get(),
FlashDevice::FlashDeviceStats::FlashDeviceStats(statistics::Group *parent)
: statistics::Group(parent, "FlashDevice"),
ADD_STAT(totalGCActivations, statistics::units::Count::get(),
"Number of Garbage collector activations"),
ADD_STAT(writeAccess, Stats::units::Count::get(),
ADD_STAT(writeAccess, statistics::units::Count::get(),
"Histogram of write addresses"),
ADD_STAT(readAccess, Stats::units::Count::get(),
ADD_STAT(readAccess, statistics::units::Count::get(),
"Histogram of read addresses"),
ADD_STAT(fileSystemAccess, Stats::units::Count::get(),
ADD_STAT(fileSystemAccess, statistics::units::Count::get(),
"Histogram of file system accesses"),
ADD_STAT(writeLatency, Stats::units::Tick::get(),
ADD_STAT(writeLatency, statistics::units::Tick::get(),
"Histogram of write latency"),
ADD_STAT(readLatency, Stats::units::Tick::get(),
ADD_STAT(readLatency, statistics::units::Tick::get(),
"Histogram of read latency")
{
using namespace Stats;
using namespace statistics;
/** Amount of GC activations*/
totalGCActivations

16
src/dev/arm/flash_device.hh
View File

@@ -93,21 +93,21 @@ class FlashDevice : public AbstractNVM
std::function<void()> function;
};
struct FlashDeviceStats : public Stats::Group
struct FlashDeviceStats : public statistics::Group
{
FlashDeviceStats(Stats::Group *parent);
FlashDeviceStats(statistics::Group *parent);
/** Amount of GC activations*/
Stats::Scalar totalGCActivations;
statistics::Scalar totalGCActivations;
/** Histogram of address accesses*/
Stats::Histogram writeAccess;
Stats::Histogram readAccess;
Stats::Histogram fileSystemAccess;
statistics::Histogram writeAccess;
statistics::Histogram readAccess;
statistics::Histogram fileSystemAccess;
/** Histogram of access latencies*/
Stats::Histogram writeLatency;
Stats::Histogram readLatency;
statistics::Histogram writeLatency;
statistics::Histogram readLatency;
};
/** Device access functions Inherrited from AbstractNVM*/

9
src/dev/arm/hdlcd.cc
View File

@@ -78,13 +78,12 @@ HDLcd::HDLcd(const HDLcdParams &p)
imgWriter = createImgWriter(imgFormat, &pixelPump.fb);
}
HDLcd::
HDLcdStats::HDLcdStats(Stats::Group *parent)
: Stats::Group(parent, "HDLcd"),
ADD_STAT(underruns, Stats::units::Count::get(),
HDLcd::HDLcdStats::HDLcdStats(statistics::Group *parent)
: statistics::Group(parent, "HDLcd"),
ADD_STAT(underruns, statistics::units::Count::get(),
"Number of buffer underruns")
{
using namespace Stats;
using namespace statistics;
underruns.flags(nozero);
}

6
src/dev/arm/hdlcd.hh
View File

@@ -411,10 +411,10 @@ class HDLcd: public AmbaDmaDevice
std::unique_ptr<DmaEngine> dmaEngine;
protected: // Statistics
struct HDLcdStats: public Stats::Group
struct HDLcdStats: public statistics::Group
{
HDLcdStats(Stats::Group *parent);
Stats::Scalar underruns;
HDLcdStats(statistics::Group *parent);
statistics::Scalar underruns;
} stats;
};

22
src/dev/arm/smmu_v3.cc
View File

@@ -745,18 +745,18 @@ SMMUv3::init()
controlPort.sendRangeChange();
}
SMMUv3::SMMUv3Stats::SMMUv3Stats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(steL1Fetches, Stats::units::Count::get(), "STE L1 fetches"),
ADD_STAT(steFetches, Stats::units::Count::get(), "STE fetches"),
ADD_STAT(cdL1Fetches, Stats::units::Count::get(), "CD L1 fetches"),
ADD_STAT(cdFetches, Stats::units::Count::get(), "CD fetches"),
ADD_STAT(translationTimeDist, Stats::units::Tick::get(),
"Time to translate address"),
ADD_STAT(ptwTimeDist, Stats::units::Tick::get(),
"Time to walk page tables")
SMMUv3::SMMUv3Stats::SMMUv3Stats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(steL1Fetches, statistics::units::Count::get(), "STE L1 fetches"),
ADD_STAT(steFetches, statistics::units::Count::get(), "STE fetches"),
ADD_STAT(cdL1Fetches, statistics::units::Count::get(), "CD L1 fetches"),
ADD_STAT(cdFetches, statistics::units::Count::get(), "CD fetches"),
ADD_STAT(translationTimeDist, statistics::units::Tick::get(),
"Time to translate address"),
ADD_STAT(ptwTimeDist, statistics::units::Tick::get(),
"Time to walk page tables")
{
using namespace Stats;
using namespace statistics;
steL1Fetches
.flags(pdf);

16
src/dev/arm/smmu_v3.hh
View File

@@ -133,15 +133,15 @@ class SMMUv3 : public ClockedObject
const Cycles walkLat;
// Stats
struct SMMUv3Stats : public Stats::Group
struct SMMUv3Stats : public statistics::Group
{
SMMUv3Stats(Stats::Group *parent);
Stats::Scalar steL1Fetches;
Stats::Scalar steFetches;
Stats::Scalar cdL1Fetches;
Stats::Scalar cdFetches;
Stats::Distribution translationTimeDist;
Stats::Distribution ptwTimeDist;
SMMUv3Stats(statistics::Group *parent);
statistics::Scalar steL1Fetches;
statistics::Scalar steFetches;
statistics::Scalar cdL1Fetches;
statistics::Scalar cdFetches;
statistics::Distribution translationTimeDist;
statistics::Distribution ptwTimeDist;
} stats;
std::vector<SMMUv3DeviceInterface *> deviceInterfaces;

80
src/dev/arm/smmu_v3_caches.cc
View File

@@ -59,7 +59,7 @@
*/
SMMUv3BaseCache::SMMUv3BaseCache(const std::string &policy_name, uint32_t seed,
Stats::Group *parent, const std::string &name)
statistics::Group *parent, const std::string &name)
: replacementPolicy(decodePolicyName(policy_name)),
nextToReplace(0),
random(seed),
@@ -83,28 +83,28 @@ SMMUv3BaseCache::decodePolicyName(const std::string &policy_name)
SMMUv3BaseCache::
SMMUv3BaseCacheStats::SMMUv3BaseCacheStats(
Stats::Group *parent, const std::string &name)
: Stats::Group(parent, name.c_str()),
ADD_STAT(averageLookups, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
statistics::Group *parent, const std::string &name)
: statistics::Group(parent, name.c_str()),
ADD_STAT(averageLookups, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Average number lookups per second"),
ADD_STAT(totalLookups, Stats::units::Count::get(),
ADD_STAT(totalLookups, statistics::units::Count::get(),
"Total number of lookups"),
ADD_STAT(averageMisses, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
ADD_STAT(averageMisses, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Average number misses per second"),
ADD_STAT(totalMisses, Stats::units::Count::get(),
ADD_STAT(totalMisses, statistics::units::Count::get(),
"Total number of misses"),
ADD_STAT(averageUpdates, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
ADD_STAT(averageUpdates, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Average number updates per second"),
ADD_STAT(totalUpdates, Stats::units::Count::get(),
ADD_STAT(totalUpdates, statistics::units::Count::get(),
"Total number of updates"),
ADD_STAT(averageHitRate, Stats::units::Ratio::get(), "Average hit rate"),
ADD_STAT(insertions, Stats::units::Count::get(),
ADD_STAT(averageHitRate, statistics::units::Ratio::get(), "Average hit rate"),
ADD_STAT(insertions, statistics::units::Count::get(),
"Number of insertions (not replacements)")
{
using namespace Stats;
using namespace statistics;
averageLookups
@@ -148,7 +148,7 @@ SMMUv3BaseCacheStats::SMMUv3BaseCacheStats(
*/
SMMUTLB::SMMUTLB(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent,
const std::string &policy, statistics::Group *parent,
const std::string &name)
:
SMMUv3BaseCache(policy, SMMUTLB_SEED, parent, name),
@@ -429,7 +429,7 @@ SMMUTLB::pickEntryIdxToReplace(const Set &set, AllocPolicy alloc)
*/
ARMArchTLB::ARMArchTLB(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent)
const std::string &policy, statistics::Group *parent)
:
SMMUv3BaseCache(policy, ARMARCHTLB_SEED, parent, "tlb"),
associativity(_associativity)
@@ -628,7 +628,7 @@ ARMArchTLB::pickEntryIdxToReplace(const Set &set)
*/
IPACache::IPACache(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent)
const std::string &policy, statistics::Group *parent)
:
SMMUv3BaseCache(policy, IPACACHE_SEED, parent, "ipa"),
associativity(_associativity)
@@ -808,7 +808,7 @@ IPACache::pickEntryIdxToReplace(const Set &set)
*/
ConfigCache::ConfigCache(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent)
const std::string &policy, statistics::Group *parent)
:
SMMUv3BaseCache(policy, CONFIGCACHE_SEED, parent, "cfg"),
associativity(_associativity)
@@ -973,7 +973,7 @@ ConfigCache::pickEntryIdxToReplace(const Set &set)
WalkCache::WalkCache(const std::array<unsigned, 2*WALK_CACHE_LEVELS> &_sizes,
unsigned _associativity, const std::string &policy,
Stats::Group *parent) :
statistics::Group *parent) :
SMMUv3BaseCache(policy, WALKCACHE_SEED, parent, "walk"),
walkCacheStats(&(SMMUv3BaseCache::baseCacheStats)),
associativity(_associativity),
@@ -1226,19 +1226,18 @@ WalkCache::pickEntryIdxToReplace(const Set &set,
}
WalkCache::
WalkCacheStats::WalkCacheStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(totalLookupsByStageLevel, Stats::units::Count::get(),
WalkCache::WalkCacheStats::WalkCacheStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(totalLookupsByStageLevel, statistics::units::Count::get(),
"Total number of lookups"),
ADD_STAT(totalMissesByStageLevel, Stats::units::Count::get(),
ADD_STAT(totalMissesByStageLevel, statistics::units::Count::get(),
"Total number of misses"),
ADD_STAT(totalUpdatesByStageLevel, Stats::units::Count::get(),
ADD_STAT(totalUpdatesByStageLevel, statistics::units::Count::get(),
"Total number of updates"),
ADD_STAT(insertionsByStageLevel, Stats::units::Count::get(),
ADD_STAT(insertionsByStageLevel, statistics::units::Count::get(),
"Number of insertions (not replacements)")
{
using namespace Stats;
using namespace statistics;
totalLookupsByStageLevel
.init(2, WALK_CACHE_LEVELS)
@@ -1265,11 +1264,11 @@ WalkCacheStats::WalkCacheStats(Stats::Group *parent)
totalUpdatesByStageLevel.ysubname(l, csprintf("L%d", l));
insertionsByStageLevel.ysubname(l, csprintf("L%d", l));
auto avg_lookup = new Stats::Formula(
auto avg_lookup = new statistics::Formula(
this,
csprintf("averageLookups_S%dL%d", s+1, l).c_str(),
Stats::units::Rate<Stats::units::Count,
Stats::units::Second>::get(),
statistics::units::Rate<statistics::units::Count,
statistics::units::Second>::get(),
"Average number lookups per second");
avg_lookup->flags(pdf);
averageLookupsByStageLevel.push_back(avg_lookup);
@@ -1277,11 +1276,11 @@ WalkCacheStats::WalkCacheStats(Stats::Group *parent)
*avg_lookup =
totalLookupsByStageLevel[s][l] / simSeconds;
auto avg_misses = new Stats::Formula(
auto avg_misses = new statistics::Formula(
this,
csprintf("averageMisses_S%dL%d", s+1, l).c_str(),
Stats::units::Rate<Stats::units::Count,
Stats::units::Second>::get(),
statistics::units::Rate<statistics::units::Count,
statistics::units::Second>::get(),
"Average number misses per second");
avg_misses->flags(pdf);
averageMissesByStageLevel.push_back(avg_misses);
@@ -1289,11 +1288,11 @@ WalkCacheStats::WalkCacheStats(Stats::Group *parent)
*avg_misses =
totalMissesByStageLevel[s][l] / simSeconds;
auto avg_updates = new Stats::Formula(
auto avg_updates = new statistics::Formula(
this,
csprintf("averageUpdates_S%dL%d", s+1, l).c_str(),
Stats::units::Rate<Stats::units::Count,
Stats::units::Second>::get(),
statistics::units::Rate<statistics::units::Count,
statistics::units::Second>::get(),
"Average number updates per second");
avg_updates->flags(pdf);
averageUpdatesByStageLevel.push_back(avg_updates);
@@ -1301,10 +1300,10 @@ WalkCacheStats::WalkCacheStats(Stats::Group *parent)
*avg_updates =
totalUpdatesByStageLevel[s][l] / simSeconds;
auto avg_hitrate = new Stats::Formula(
auto avg_hitrate = new statistics::Formula(
this,
csprintf("averageHitRate_S%dL%d", s+1, l).c_str(),
Stats::units::Ratio::get(), "Average hit rate");
statistics::units::Ratio::get(), "Average hit rate");
avg_hitrate->flags(pdf);
averageHitRateByStageLevel.push_back(avg_hitrate);
@@ -1317,8 +1316,7 @@ WalkCacheStats::WalkCacheStats(Stats::Group *parent)
}
}
WalkCache::
WalkCacheStats::~WalkCacheStats()
WalkCache::WalkCacheStats::~WalkCacheStats()
{
for (auto avg_lookup : averageLookupsByStageLevel)
delete avg_lookup;

53
src/dev/arm/smmu_v3_caches.hh
View File

@@ -66,29 +66,30 @@ class SMMUv3BaseCache
Random random;
uint32_t useStamp;
struct SMMUv3BaseCacheStats : public Stats::Group
struct SMMUv3BaseCacheStats : public statistics::Group
{
SMMUv3BaseCacheStats(Stats::Group *parent, const std::string &name);
SMMUv3BaseCacheStats(statistics::Group *parent,
const std::string &name);
Stats::Formula averageLookups;
Stats::Scalar totalLookups;
statistics::Formula averageLookups;
statistics::Scalar totalLookups;
Stats::Formula averageMisses;
Stats::Scalar totalMisses;
statistics::Formula averageMisses;
statistics::Scalar totalMisses;
Stats::Formula averageUpdates;
Stats::Scalar totalUpdates;
statistics::Formula averageUpdates;
statistics::Scalar totalUpdates;
Stats::Formula averageHitRate;
statistics::Formula averageHitRate;
Stats::Scalar insertions;
statistics::Scalar insertions;
} baseCacheStats;
static int decodePolicyName(const std::string &policy_name);
public:
SMMUv3BaseCache(const std::string &policy_name, uint32_t seed,
Stats::Group *parent, const std::string &name);
statistics::Group *parent, const std::string &name);
virtual ~SMMUv3BaseCache() {}
};
@@ -124,7 +125,7 @@ class SMMUTLB : public SMMUv3BaseCache
};
SMMUTLB(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent,
const std::string &policy, statistics::Group *parent,
const std::string &name);
SMMUTLB(const SMMUTLB& tlb) = delete;
virtual ~SMMUTLB() {}
@@ -174,7 +175,7 @@ class ARMArchTLB : public SMMUv3BaseCache
};
ARMArchTLB(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent);
const std::string &policy, statistics::Group *parent);
virtual ~ARMArchTLB() {}
const Entry *lookup(Addr va, uint16_t asid, uint16_t vmid,
@@ -217,7 +218,7 @@ class IPACache : public SMMUv3BaseCache
};
IPACache(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent);
const std::string &policy, statistics::Group *parent);
virtual ~IPACache() {}
const Entry *lookup(Addr ipa, uint16_t vmid, bool updStats=true);
@@ -265,7 +266,7 @@ class ConfigCache : public SMMUv3BaseCache
};
ConfigCache(unsigned numEntries, unsigned _associativity,
const std::string &policy, Stats::Group *parent);
const std::string &policy, statistics::Group *parent);
virtual ~ConfigCache() {}
const Entry *lookup(uint32_t sid, uint32_t ssid, bool updStats=true);
@@ -309,7 +310,7 @@ class WalkCache : public SMMUv3BaseCache
WalkCache(const std::array<unsigned, 2*WALK_CACHE_LEVELS> &_sizes,
unsigned _associativity, const std::string &policy,
Stats::Group *parent);
statistics::Group *parent);
virtual ~WalkCache() {}
const Entry *lookup(Addr va, Addr vaMask, uint16_t asid, uint16_t vmid,
@@ -324,23 +325,23 @@ class WalkCache : public SMMUv3BaseCache
void invalidateAll();
protected:
struct WalkCacheStats : public Stats::Group
struct WalkCacheStats : public statistics::Group
{
WalkCacheStats(Stats::Group *parent);
WalkCacheStats(statistics::Group *parent);
~WalkCacheStats();
std::vector<Stats::Formula*> averageLookupsByStageLevel;
Stats::Vector2d totalLookupsByStageLevel;
std::vector<statistics::Formula*> averageLookupsByStageLevel;
statistics::Vector2d totalLookupsByStageLevel;
std::vector<Stats::Formula*> averageMissesByStageLevel;
Stats::Vector2d totalMissesByStageLevel;
std::vector<statistics::Formula*> averageMissesByStageLevel;
statistics::Vector2d totalMissesByStageLevel;
std::vector<Stats::Formula*> averageUpdatesByStageLevel;
Stats::Vector2d totalUpdatesByStageLevel;
std::vector<statistics::Formula*> averageUpdatesByStageLevel;
statistics::Vector2d totalUpdatesByStageLevel;
std::vector<Stats::Formula*> averageHitRateByStageLevel;
std::vector<statistics::Formula*> averageHitRateByStageLevel;
Stats::Vector2d insertionsByStageLevel;
statistics::Vector2d insertionsByStageLevel;
} walkCacheStats;
private:
typedef std::vector<Entry> Set;

54
src/dev/arm/ufs_device.cc
View File

@@ -755,59 +755,59 @@ UFSHostDevice::UFSHostDevice(const UFSHostDeviceParams &p) :
UFSHostDevice::
UFSHostDeviceStats::UFSHostDeviceStats(UFSHostDevice *parent)
: Stats::Group(parent, "UFSDiskHost"),
ADD_STAT(currentSCSIQueue, Stats::units::Count::get(),
: statistics::Group(parent, "UFSDiskHost"),
ADD_STAT(currentSCSIQueue, statistics::units::Count::get(),
"Most up to date length of the command queue"),
ADD_STAT(currentReadSSDQueue, Stats::units::Count::get(),
ADD_STAT(currentReadSSDQueue, statistics::units::Count::get(),
"Most up to date length of the read SSD queue"),
ADD_STAT(currentWriteSSDQueue, Stats::units::Count::get(),
ADD_STAT(currentWriteSSDQueue, statistics::units::Count::get(),
"Most up to date length of the write SSD queue"),
/** Amount of data read/written */
ADD_STAT(totalReadSSD, Stats::units::Byte::get(),
ADD_STAT(totalReadSSD, statistics::units::Byte::get(),
"Number of bytes read from SSD"),
ADD_STAT(totalWrittenSSD, Stats::units::Byte::get(),
ADD_STAT(totalWrittenSSD, statistics::units::Byte::get(),
"Number of bytes written to SSD"),
ADD_STAT(totalReadDiskTransactions, Stats::units::Count::get(),
ADD_STAT(totalReadDiskTransactions, statistics::units::Count::get(),
"Number of transactions from disk"),
ADD_STAT(totalWriteDiskTransactions, Stats::units::Count::get(),
ADD_STAT(totalWriteDiskTransactions, statistics::units::Count::get(),
"Number of transactions to disk"),
ADD_STAT(totalReadUFSTransactions, Stats::units::Count::get(),
ADD_STAT(totalReadUFSTransactions, statistics::units::Count::get(),
"Number of transactions from device"),
ADD_STAT(totalWriteUFSTransactions, Stats::units::Count::get(),
ADD_STAT(totalWriteUFSTransactions, statistics::units::Count::get(),
"Number of transactions to device"),
/** Average bandwidth for reads and writes */
ADD_STAT(averageReadSSDBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(averageReadSSDBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average read bandwidth",
totalReadSSD / simSeconds),
ADD_STAT(averageWriteSSDBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(averageWriteSSDBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average write bandwidth",
totalWrittenSSD / simSeconds),
ADD_STAT(averageSCSIQueue, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(averageSCSIQueue, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average command queue length"),
ADD_STAT(averageReadSSDQueue, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(averageReadSSDQueue, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average read queue length"),
ADD_STAT(averageWriteSSDQueue, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(averageWriteSSDQueue, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average write queue length"),
/** Number of doorbells rung*/
ADD_STAT(curDoorbell, Stats::units::Count::get(),
ADD_STAT(curDoorbell, statistics::units::Count::get(),
"Most up to date number of doorbells used",
parent->activeDoorbells),
ADD_STAT(maxDoorbell, Stats::units::Count::get(),
ADD_STAT(maxDoorbell, statistics::units::Count::get(),
"Maximum number of doorbells utilized"),
ADD_STAT(averageDoorbell, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(averageDoorbell, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average number of Doorbells used"),
/** Latency*/
ADD_STAT(transactionLatency, Stats::units::Tick::get(),
ADD_STAT(transactionLatency, statistics::units::Tick::get(),
"Histogram of transaction times"),
ADD_STAT(idleTimes, Stats::units::Tick::get(), "Histogram of idle times")
ADD_STAT(idleTimes, statistics::units::Tick::get(), "Histogram of idle times")
{
using namespace Stats;
using namespace statistics;
// Register the stats
/** Queue lengths */

40
src/dev/arm/ufs_device.hh
View File

@@ -512,40 +512,40 @@ class UFSHostDevice : public DmaDevice
/**
* Statistics
*/
struct UFSHostDeviceStats : public Stats::Group
struct UFSHostDeviceStats : public statistics::Group
{
UFSHostDeviceStats(UFSHostDevice *parent);
/** Queue lengths */
Stats::Scalar currentSCSIQueue;
Stats::Scalar currentReadSSDQueue;
Stats::Scalar currentWriteSSDQueue;
statistics::Scalar currentSCSIQueue;
statistics::Scalar currentReadSSDQueue;
statistics::Scalar currentWriteSSDQueue;
/** Amount of data read/written */
Stats::Scalar totalReadSSD;
Stats::Scalar totalWrittenSSD;
Stats::Scalar totalReadDiskTransactions;
Stats::Scalar totalWriteDiskTransactions;
Stats::Scalar totalReadUFSTransactions;
Stats::Scalar totalWriteUFSTransactions;
statistics::Scalar totalReadSSD;
statistics::Scalar totalWrittenSSD;
statistics::Scalar totalReadDiskTransactions;
statistics::Scalar totalWriteDiskTransactions;
statistics::Scalar totalReadUFSTransactions;
statistics::Scalar totalWriteUFSTransactions;
/** Average bandwidth for reads and writes */
Stats::Formula averageReadSSDBW;
Stats::Formula averageWriteSSDBW;
statistics::Formula averageReadSSDBW;
statistics::Formula averageWriteSSDBW;
/** Average Queue lengths*/
Stats::Average averageSCSIQueue;
Stats::Average averageReadSSDQueue;
Stats::Average averageWriteSSDQueue;
statistics::Average averageSCSIQueue;
statistics::Average averageReadSSDQueue;
statistics::Average averageWriteSSDQueue;
/** Number of doorbells rung*/
Stats::Formula curDoorbell;
Stats::Scalar maxDoorbell;
Stats::Average averageDoorbell;
statistics::Formula curDoorbell;
statistics::Scalar maxDoorbell;
statistics::Average averageDoorbell;
/** Histogram of latencies*/
Stats::Histogram transactionLatency;
Stats::Histogram idleTimes;
statistics::Histogram transactionLatency;
statistics::Histogram idleTimes;
};
/**

136
src/dev/net/etherdevice.cc
View File

@@ -30,133 +30,133 @@
#include "sim/stats.hh"
EtherDevice::EtherDeviceStats::EtherDeviceStats(Stats::Group *parent)
: Stats::Group(parent, "EtherDevice"),
ADD_STAT(postedInterrupts, Stats::units::Count::get(),
EtherDevice::EtherDeviceStats::EtherDeviceStats(statistics::Group *parent)
: statistics::Group(parent, "EtherDevice"),
ADD_STAT(postedInterrupts, statistics::units::Count::get(),
"Number of posts to CPU"),
ADD_STAT(txBytes, Stats::units::Byte::get(),
ADD_STAT(txBytes, statistics::units::Byte::get(),
"Bytes Transmitted"),
ADD_STAT(rxBytes, Stats::units::Byte::get(), "Bytes Received"),
ADD_STAT(txPackets, Stats::units::Count::get(),
ADD_STAT(rxBytes, statistics::units::Byte::get(), "Bytes Received"),
ADD_STAT(txPackets, statistics::units::Count::get(),
"Number of Packets Transmitted"),
ADD_STAT(rxPackets, Stats::units::Count::get(),
ADD_STAT(rxPackets, statistics::units::Count::get(),
"Number of Packets Received"),
ADD_STAT(txBandwidth, Stats::units::Rate<
Stats::units::Bit, Stats::units::Second>::get(),
ADD_STAT(txBandwidth, statistics::units::Rate<
statistics::units::Bit, statistics::units::Second>::get(),
"Transmit Bandwidth",
txBytes * Stats::constant(8) / simSeconds),
ADD_STAT(rxBandwidth, Stats::units::Rate<
Stats::units::Bit, Stats::units::Second>::get(),
txBytes * statistics::constant(8) / simSeconds),
ADD_STAT(rxBandwidth, statistics::units::Rate<
statistics::units::Bit, statistics::units::Second>::get(),
"Receive Bandwidth",
rxBytes * Stats::constant(8) / simSeconds),
ADD_STAT(txIpChecksums, Stats::units::Count::get(),
rxBytes * statistics::constant(8) / simSeconds),
ADD_STAT(txIpChecksums, statistics::units::Count::get(),
"Number of tx IP Checksums done by device"),
ADD_STAT(rxIpChecksums, Stats::units::Count::get(),
ADD_STAT(rxIpChecksums, statistics::units::Count::get(),
"Number of rx IP Checksums done by device"),
ADD_STAT(txTcpChecksums, Stats::units::Count::get(),
ADD_STAT(txTcpChecksums, statistics::units::Count::get(),
"Number of tx TCP Checksums done by device"),
ADD_STAT(rxTcpChecksums, Stats::units::Count::get(),
ADD_STAT(rxTcpChecksums, statistics::units::Count::get(),
"Number of rx TCP Checksums done by device"),
ADD_STAT(txUdpChecksums, Stats::units::Count::get(),
ADD_STAT(txUdpChecksums, statistics::units::Count::get(),
"Number of tx UDP Checksums done by device"),
ADD_STAT(rxUdpChecksums, Stats::units::Count::get(),
ADD_STAT(rxUdpChecksums, statistics::units::Count::get(),
"Number of rx UDP Checksums done by device"),
ADD_STAT(descDmaReads, Stats::units::Count::get(),
ADD_STAT(descDmaReads, statistics::units::Count::get(),
"Number of descriptors the device read w/ DMA"),
ADD_STAT(descDmaWrites, Stats::units::Count::get(),
ADD_STAT(descDmaWrites, statistics::units::Count::get(),
"Number of descriptors the device wrote w/ DMA"),
ADD_STAT(descDmaRdBytes, Stats::units::Count::get(),
ADD_STAT(descDmaRdBytes, statistics::units::Count::get(),
"Number of descriptor bytes read w/ DMA"),
ADD_STAT(descDmaWrBytes, Stats::units::Count::get(),
ADD_STAT(descDmaWrBytes, statistics::units::Count::get(),
"Number of descriptor bytes write w/ DMA"),
ADD_STAT(totBandwidth, Stats::units::Rate<
Stats::units::Bit, Stats::units::Second>::get(),
ADD_STAT(totBandwidth, statistics::units::Rate<
statistics::units::Bit, statistics::units::Second>::get(),
"Total Bandwidth",
txBandwidth + rxBandwidth),
ADD_STAT(totPackets, Stats::units::Count::get(), "Total Packets",
ADD_STAT(totPackets, statistics::units::Count::get(), "Total Packets",
txPackets + rxPackets),
ADD_STAT(totBytes, Stats::units::Byte::get(), "Total Bytes",
ADD_STAT(totBytes, statistics::units::Byte::get(), "Total Bytes",
txBytes + rxBytes),
ADD_STAT(totPacketRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
ADD_STAT(totPacketRate, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Total Packet Tranmission Rate",
totPackets / simSeconds),
ADD_STAT(txPacketRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
ADD_STAT(txPacketRate, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Packet Tranmission Rate",
txPackets / simSeconds),
ADD_STAT(rxPacketRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
ADD_STAT(rxPacketRate, statistics::units::Rate<
statistics::units::Count, statistics::units::Second>::get(),
"Packet Reception Rate",
rxPackets / simSeconds),
ADD_STAT(postedSwi, Stats::units::Count::get(),
ADD_STAT(postedSwi, statistics::units::Count::get(),
"Number of software interrupts posted to CPU"),
ADD_STAT(totalSwi, Stats::units::Count::get(),
ADD_STAT(totalSwi, statistics::units::Count::get(),
"Total number of Swi written to ISR"),
ADD_STAT(coalescedSwi, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedSwi, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of Swi's coalesced into each post",
totalSwi / postedInterrupts),
ADD_STAT(postedRxIdle, Stats::units::Count::get(),
ADD_STAT(postedRxIdle, statistics::units::Count::get(),
"Number of rxIdle interrupts posted to CPU"),
ADD_STAT(totalRxIdle, Stats::units::Count::get(),
ADD_STAT(totalRxIdle, statistics::units::Count::get(),
"Total number of RxIdle written to ISR"),
ADD_STAT(coalescedRxIdle, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedRxIdle, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of RxIdle's coalesced into each post",
totalRxIdle / postedInterrupts),
ADD_STAT(postedRxOk, Stats::units::Count::get(),
ADD_STAT(postedRxOk, statistics::units::Count::get(),
"Number of RxOk interrupts posted to CPU"),
ADD_STAT(totalRxOk, Stats::units::Count::get(),
ADD_STAT(totalRxOk, statistics::units::Count::get(),
"Total number of RxOk written to ISR"),
ADD_STAT(coalescedRxOk, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedRxOk, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of RxOk's coalesced into each post",
totalRxOk / postedInterrupts),
ADD_STAT(postedRxDesc, Stats::units::Count::get(),
ADD_STAT(postedRxDesc, statistics::units::Count::get(),
"Number of RxDesc interrupts posted to CPU"),
ADD_STAT(totalRxDesc, Stats::units::Count::get(),
ADD_STAT(totalRxDesc, statistics::units::Count::get(),
"Total number of RxDesc written to ISR"),
ADD_STAT(coalescedRxDesc, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedRxDesc, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of RxDesc's coalesced into each post",
totalRxDesc / postedInterrupts),
ADD_STAT(postedTxOk, Stats::units::Count::get(),
ADD_STAT(postedTxOk, statistics::units::Count::get(),
"Number of TxOk interrupts posted to CPU"),
ADD_STAT(totalTxOk, Stats::units::Count::get(),
ADD_STAT(totalTxOk, statistics::units::Count::get(),
"Total number of TxOk written to ISR"),
ADD_STAT(coalescedTxOk, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedTxOk, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of TxOk's coalesced into each post",
totalTxOk / postedInterrupts),
ADD_STAT(postedTxIdle, Stats::units::Count::get(),
ADD_STAT(postedTxIdle, statistics::units::Count::get(),
"Number of TxIdle interrupts posted to CPU"),
ADD_STAT(totalTxIdle, Stats::units::Count::get(),
ADD_STAT(totalTxIdle, statistics::units::Count::get(),
"Total number of TxIdle written to ISR"),
ADD_STAT(coalescedTxIdle, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedTxIdle, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of TxIdle's coalesced into each post",
totalTxIdle / postedInterrupts),
ADD_STAT(postedTxDesc, Stats::units::Count::get(),
ADD_STAT(postedTxDesc, statistics::units::Count::get(),
"Number of TxDesc interrupts posted to CPU"),
ADD_STAT(totalTxDesc, Stats::units::Count::get(),
ADD_STAT(totalTxDesc, statistics::units::Count::get(),
"Total number of TxDesc written to ISR"),
ADD_STAT(coalescedTxDesc, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedTxDesc, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of TxDesc's coalesced into each post",
totalTxDesc / postedInterrupts),
ADD_STAT(postedRxOrn, Stats::units::Count::get(),
ADD_STAT(postedRxOrn, statistics::units::Count::get(),
"Number of RxOrn posted to CPU"),
ADD_STAT(totalRxOrn, Stats::units::Count::get(),
ADD_STAT(totalRxOrn, statistics::units::Count::get(),
"Total number of RxOrn written to ISR"),
ADD_STAT(coalescedRxOrn, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedRxOrn, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of RxOrn's coalesced into each post",
totalRxOrn / postedInterrupts),
ADD_STAT(coalescedTotal, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(coalescedTotal, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of interrupts coalesced into each post"),
ADD_STAT(droppedPackets, Stats::units::Count::get(),
ADD_STAT(droppedPackets, statistics::units::Count::get(),
"Number of packets dropped")
{

102
src/dev/net/etherdevice.hh
View File

@@ -52,78 +52,78 @@ class EtherDevice : public PciDevice
{}
protected:
struct EtherDeviceStats : public Stats::Group
struct EtherDeviceStats : public statistics::Group
{
EtherDeviceStats(Stats::Group *parent);
EtherDeviceStats(statistics::Group *parent);
Stats::Scalar postedInterrupts;
statistics::Scalar postedInterrupts;
Stats::Scalar txBytes;
Stats::Scalar rxBytes;
statistics::Scalar txBytes;
statistics::Scalar rxBytes;
Stats::Scalar txPackets;
Stats::Scalar rxPackets;
statistics::Scalar txPackets;
statistics::Scalar rxPackets;
Stats::Formula txBandwidth;
Stats::Formula rxBandwidth;
statistics::Formula txBandwidth;
statistics::Formula rxBandwidth;
Stats::Scalar txIpChecksums;
Stats::Scalar rxIpChecksums;
statistics::Scalar txIpChecksums;
statistics::Scalar rxIpChecksums;
Stats::Scalar txTcpChecksums;
Stats::Scalar rxTcpChecksums;
statistics::Scalar txTcpChecksums;
statistics::Scalar rxTcpChecksums;
Stats::Scalar txUdpChecksums;
Stats::Scalar rxUdpChecksums;
statistics::Scalar txUdpChecksums;
statistics::Scalar rxUdpChecksums;
Stats::Scalar descDmaReads;
Stats::Scalar descDmaWrites;
statistics::Scalar descDmaReads;
statistics::Scalar descDmaWrites;
Stats::Scalar descDmaRdBytes;
Stats::Scalar descDmaWrBytes;
statistics::Scalar descDmaRdBytes;
statistics::Scalar descDmaWrBytes;
Stats::Formula totBandwidth;
Stats::Formula totPackets;
Stats::Formula totBytes;
Stats::Formula totPacketRate;
statistics::Formula totBandwidth;
statistics::Formula totPackets;
statistics::Formula totBytes;
statistics::Formula totPacketRate;
Stats::Formula txPacketRate;
Stats::Formula rxPacketRate;
statistics::Formula txPacketRate;
statistics::Formula rxPacketRate;
Stats::Scalar postedSwi;
Stats::Scalar totalSwi;
Stats::Formula coalescedSwi;
statistics::Scalar postedSwi;
statistics::Scalar totalSwi;
statistics::Formula coalescedSwi;
Stats::Scalar postedRxIdle;
Stats::Scalar totalRxIdle;
Stats::Formula coalescedRxIdle;
statistics::Scalar postedRxIdle;
statistics::Scalar totalRxIdle;
statistics::Formula coalescedRxIdle;
Stats::Scalar postedRxOk;
Stats::Scalar totalRxOk;
Stats::Formula coalescedRxOk;
statistics::Scalar postedRxOk;
statistics::Scalar totalRxOk;
statistics::Formula coalescedRxOk;
Stats::Scalar postedRxDesc;
Stats::Scalar totalRxDesc;
Stats::Formula coalescedRxDesc;
statistics::Scalar postedRxDesc;
statistics::Scalar totalRxDesc;
statistics::Formula coalescedRxDesc;
Stats::Scalar postedTxOk;
Stats::Scalar totalTxOk;
Stats::Formula coalescedTxOk;
statistics::Scalar postedTxOk;
statistics::Scalar totalTxOk;
statistics::Formula coalescedTxOk;
Stats::Scalar postedTxIdle;
Stats::Scalar totalTxIdle;
Stats::Formula coalescedTxIdle;
statistics::Scalar postedTxIdle;
statistics::Scalar totalTxIdle;
statistics::Formula coalescedTxIdle;
Stats::Scalar postedTxDesc;
Stats::Scalar totalTxDesc;
Stats::Formula coalescedTxDesc;
statistics::Scalar postedTxDesc;
statistics::Scalar totalTxDesc;
statistics::Formula coalescedTxDesc;
Stats::Scalar postedRxOrn;
Stats::Scalar totalRxOrn;
Stats::Formula coalescedRxOrn;
statistics::Scalar postedRxOrn;
statistics::Scalar totalRxOrn;
statistics::Formula coalescedRxOrn;
Stats::Formula coalescedTotal;
Stats::Scalar droppedPackets;
statistics::Formula coalescedTotal;
statistics::Scalar droppedPackets;
} etherDeviceStats;
};

14
src/dev/net/sinic.cc
View File

@@ -98,16 +98,16 @@ Device::Device(const Params &p)
Device::~Device()
{}
Device::DeviceStats::DeviceStats(Stats::Group *parent)
: Stats::Group(parent, "SinicDevice"),
ADD_STAT(totalVnicDistance, Stats::units::Count::get(),
Device::DeviceStats::DeviceStats(statistics::Group *parent)
: statistics::Group(parent, "SinicDevice"),
ADD_STAT(totalVnicDistance, statistics::units::Count::get(),
"Total vnic distance"),
ADD_STAT(numVnicDistance, Stats::units::Count::get(),
ADD_STAT(numVnicDistance, statistics::units::Count::get(),
"Number of vnic distance measurements"),
ADD_STAT(maxVnicDistance, Stats::units::Count::get(),
ADD_STAT(maxVnicDistance, statistics::units::Count::get(),
"Maximum vnic distance"),
ADD_STAT(avgVnicDistance, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(avgVnicDistance, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average vnic distance", totalVnicDistance / numVnicDistance),
_maxVnicDistance(0)
{

12
src/dev/net/sinic.hh
View File

@@ -277,14 +277,14 @@ class Device : public Base
* Statistics
*/
private:
struct DeviceStats : public Stats::Group
struct DeviceStats : public statistics::Group
{
DeviceStats(Stats::Group *parent);
DeviceStats(statistics::Group *parent);
Stats::Scalar totalVnicDistance;
Stats::Scalar numVnicDistance;
Stats::Scalar maxVnicDistance;
Stats::Formula avgVnicDistance;
statistics::Scalar totalVnicDistance;
statistics::Scalar numVnicDistance;
statistics::Scalar maxVnicDistance;
statistics::Formula avgVnicDistance;
int _maxVnicDistance;
} sinicDeviceStats;

12
src/dev/pci/copy_engine.cc
View File

@@ -428,21 +428,21 @@ CopyEngine::CopyEngineChannel::channelWrite(Packet *pkt, Addr daddr, int size)
}
CopyEngine::
CopyEngineStats::CopyEngineStats(Stats::Group *parent,
CopyEngineStats::CopyEngineStats(statistics::Group *parent,
const uint8_t &channel_count)
: Stats::Group(parent, "CopyEngine"),
ADD_STAT(bytesCopied, Stats::units::Byte::get(),
: statistics::Group(parent, "CopyEngine"),
ADD_STAT(bytesCopied, statistics::units::Byte::get(),
"Number of bytes copied by each engine"),
ADD_STAT(copiesProcessed, Stats::units::Count::get(),
ADD_STAT(copiesProcessed, statistics::units::Count::get(),
"Number of copies processed by each engine")
{
bytesCopied
.init(channel_count)
.flags(Stats::total)
.flags(statistics::total)
;
copiesProcessed
.init(channel_count)
.flags(Stats::total)
.flags(statistics::total)
;
}

17
src/dev/pci/copy_engine.hh
View File

@@ -95,7 +95,13 @@ class CopyEngine : public PciDevice
virtual ~CopyEngineChannel();
Port &getPort();
std::string name() { assert(ce); return ce->name() + csprintf("-chan%d", channelId); }
std::string
name()
{
assert(ce);
return ce->name() + csprintf("-chan%d", channelId);
}
virtual Tick read(PacketPtr pkt)
{ panic("CopyEngineChannel has no I/O access\n");}
virtual Tick write(PacketPtr pkt)
@@ -140,12 +146,13 @@ class CopyEngine : public PciDevice
private:
struct CopyEngineStats : public Stats::Group
struct CopyEngineStats : public statistics::Group
{
CopyEngineStats(Stats::Group *parent, const uint8_t& channel_count);
CopyEngineStats(statistics::Group *parent,
const uint8_t& channel_count);
Stats::Vector bytesCopied;
Stats::Vector copiesProcessed;
statistics::Vector bytesCopied;
statistics::Vector copiesProcessed;
} copyEngineStats;
// device registers

16
src/dev/storage/ide_disk.cc
View File

@@ -389,19 +389,19 @@ IdeDisk::doDmaDataRead()
}
IdeDisk::
IdeDiskStats::IdeDiskStats(Stats::Group *parent)
: Stats::Group(parent, "IdeDisk"),
ADD_STAT(dmaReadFullPages, Stats::units::Count::get(),
IdeDiskStats::IdeDiskStats(statistics::Group *parent)
: statistics::Group(parent, "IdeDisk"),
ADD_STAT(dmaReadFullPages, statistics::units::Count::get(),
"Number of full page size DMA reads (not PRD)."),
ADD_STAT(dmaReadBytes, Stats::units::Byte::get(),
ADD_STAT(dmaReadBytes, statistics::units::Byte::get(),
"Number of bytes transfered via DMA reads (not PRD)."),
ADD_STAT(dmaReadTxs, Stats::units::Count::get(),
ADD_STAT(dmaReadTxs, statistics::units::Count::get(),
"Number of DMA read transactions (not PRD)."),
ADD_STAT(dmaWriteFullPages, Stats::units::Count::get(),
ADD_STAT(dmaWriteFullPages, statistics::units::Count::get(),
"Number of full page size DMA writes."),
ADD_STAT(dmaWriteBytes, Stats::units::Byte::get(),
ADD_STAT(dmaWriteBytes, statistics::units::Byte::get(),
"Number of bytes transfered via DMA writes."),
ADD_STAT(dmaWriteTxs, Stats::units::Count::get(),
ADD_STAT(dmaWriteTxs, statistics::units::Count::get(),
"Number of DMA write transactions.")
{
}

16
src/dev/storage/ide_disk.hh
View File

@@ -260,16 +260,16 @@ class IdeDisk : public SimObject
/** DMA Aborted */
bool dmaAborted;
struct IdeDiskStats : public Stats::Group
struct IdeDiskStats : public statistics::Group
{
IdeDiskStats(Stats::Group *parent);
IdeDiskStats(statistics::Group *parent);
Stats::Scalar dmaReadFullPages;
Stats::Scalar dmaReadBytes;
Stats::Scalar dmaReadTxs;
Stats::Scalar dmaWriteFullPages;
Stats::Scalar dmaWriteBytes;
Stats::Scalar dmaWriteTxs;
statistics::Scalar dmaReadFullPages;
statistics::Scalar dmaReadBytes;
statistics::Scalar dmaReadTxs;
statistics::Scalar dmaWriteFullPages;
statistics::Scalar dmaWriteBytes;
statistics::Scalar dmaWriteTxs;
} ideDiskStats;
public: