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

34
src/mem/abstract_mem.cc
View File

@@ -110,31 +110,31 @@ AbstractMemory::setBackingStore(uint8_t* pmem_addr)
}
AbstractMemory::MemStats::MemStats(AbstractMemory &_mem)
: Stats::Group(&_mem), mem(_mem),
ADD_STAT(bytesRead, Stats::units::Byte::get(),
: statistics::Group(&_mem), mem(_mem),
ADD_STAT(bytesRead, statistics::units::Byte::get(),
"Number of bytes read from this memory"),
ADD_STAT(bytesInstRead, Stats::units::Byte::get(),
ADD_STAT(bytesInstRead, statistics::units::Byte::get(),
"Number of instructions bytes read from this memory"),
ADD_STAT(bytesWritten, Stats::units::Byte::get(),
ADD_STAT(bytesWritten, statistics::units::Byte::get(),
"Number of bytes written to this memory"),
ADD_STAT(numReads, Stats::units::Count::get(),
ADD_STAT(numReads, statistics::units::Count::get(),
"Number of read requests responded to by this memory"),
ADD_STAT(numWrites, Stats::units::Count::get(),
ADD_STAT(numWrites, statistics::units::Count::get(),
"Number of write requests responded to by this memory"),
ADD_STAT(numOther, Stats::units::Count::get(),
ADD_STAT(numOther, statistics::units::Count::get(),
"Number of other requests responded to by this memory"),
ADD_STAT(bwRead, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(bwRead, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Total read bandwidth from this memory"),
ADD_STAT(bwInstRead,
Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Instruction read bandwidth from this memory"),
ADD_STAT(bwWrite, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(bwWrite, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Write bandwidth from this memory"),
ADD_STAT(bwTotal, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(bwTotal, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Total bandwidth to/from this memory")
{
}
@@ -142,9 +142,9 @@ AbstractMemory::MemStats::MemStats(AbstractMemory &_mem)
void
AbstractMemory::MemStats::regStats()
{
using namespace Stats;
using namespace statistics;
Stats::Group::regStats();
statistics::Group::regStats();
System *sys = mem.system();
assert(sys);

22
src/mem/abstract_mem.hh
View File

@@ -165,7 +165,7 @@ class AbstractMemory : public ClockedObject
*/
System *_system;
struct MemStats : public Stats::Group
struct MemStats : public statistics::Group
{
MemStats(AbstractMemory &mem);
@@ -174,25 +174,25 @@ class AbstractMemory : public ClockedObject
const AbstractMemory &mem;
/** Number of total bytes read from this memory */
Stats::Vector bytesRead;
statistics::Vector bytesRead;
/** Number of instruction bytes read from this memory */
Stats::Vector bytesInstRead;
statistics::Vector bytesInstRead;
/** Number of bytes written to this memory */
Stats::Vector bytesWritten;
statistics::Vector bytesWritten;
/** Number of read requests */
Stats::Vector numReads;
statistics::Vector numReads;
/** Number of write requests */
Stats::Vector numWrites;
statistics::Vector numWrites;
/** Number of other requests */
Stats::Vector numOther;
statistics::Vector numOther;
/** Read bandwidth from this memory */
Stats::Formula bwRead;
statistics::Formula bwRead;
/** Read bandwidth from this memory */
Stats::Formula bwInstRead;
statistics::Formula bwInstRead;
/** Write bandwidth from this memory */
Stats::Formula bwWrite;
statistics::Formula bwWrite;
/** Total bandwidth from this memory */
Stats::Formula bwTotal;
statistics::Formula bwTotal;
} stats;

124
src/mem/cache/base.cc vendored
View File

@@ -1927,37 +1927,37 @@ BaseCache::unserialize(CheckpointIn &cp)
BaseCache::CacheCmdStats::CacheCmdStats(BaseCache &c,
const std::string &name)
: Stats::Group(&c, name.c_str()), cache(c),
ADD_STAT(hits, Stats::units::Count::get(),
: statistics::Group(&c, name.c_str()), cache(c),
ADD_STAT(hits, statistics::units::Count::get(),
("number of " + name + " hits").c_str()),
ADD_STAT(misses, Stats::units::Count::get(),
ADD_STAT(misses, statistics::units::Count::get(),
("number of " + name + " misses").c_str()),
ADD_STAT(missLatency, Stats::units::Tick::get(),
ADD_STAT(missLatency, statistics::units::Tick::get(),
("number of " + name + " miss ticks").c_str()),
ADD_STAT(accesses, Stats::units::Count::get(),
ADD_STAT(accesses, statistics::units::Count::get(),
("number of " + name + " accesses(hits+misses)").c_str()),
ADD_STAT(missRate, Stats::units::Ratio::get(),
ADD_STAT(missRate, statistics::units::Ratio::get(),
("miss rate for " + name + " accesses").c_str()),
ADD_STAT(avgMissLatency, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgMissLatency, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
("average " + name + " miss latency").c_str()),
ADD_STAT(mshrHits, Stats::units::Count::get(),
ADD_STAT(mshrHits, statistics::units::Count::get(),
("number of " + name + " MSHR hits").c_str()),
ADD_STAT(mshrMisses, Stats::units::Count::get(),
ADD_STAT(mshrMisses, statistics::units::Count::get(),
("number of " + name + " MSHR misses").c_str()),
ADD_STAT(mshrUncacheable, Stats::units::Count::get(),
ADD_STAT(mshrUncacheable, statistics::units::Count::get(),
("number of " + name + " MSHR uncacheable").c_str()),
ADD_STAT(mshrMissLatency, Stats::units::Tick::get(),
ADD_STAT(mshrMissLatency, statistics::units::Tick::get(),
("number of " + name + " MSHR miss ticks").c_str()),
ADD_STAT(mshrUncacheableLatency, Stats::units::Tick::get(),
ADD_STAT(mshrUncacheableLatency, statistics::units::Tick::get(),
("number of " + name + " MSHR uncacheable ticks").c_str()),
ADD_STAT(mshrMissRate, Stats::units::Ratio::get(),
ADD_STAT(mshrMissRate, statistics::units::Ratio::get(),
("mshr miss rate for " + name + " accesses").c_str()),
ADD_STAT(avgMshrMissLatency, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgMshrMissLatency, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
("average " + name + " mshr miss latency").c_str()),
ADD_STAT(avgMshrUncacheableLatency, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgMshrUncacheableLatency, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
("average " + name + " mshr uncacheable latency").c_str())
{
}
@@ -1965,9 +1965,9 @@ BaseCache::CacheCmdStats::CacheCmdStats(BaseCache &c,
void
BaseCache::CacheCmdStats::regStatsFromParent()
{
using namespace Stats;
using namespace statistics;
Stats::Group::regStats();
statistics::Group::regStats();
System *system = cache.system;
const auto max_requestors = system->maxRequestors();
@@ -2088,78 +2088,78 @@ BaseCache::CacheCmdStats::regStatsFromParent()
}
BaseCache::CacheStats::CacheStats(BaseCache &c)
: Stats::Group(&c), cache(c),
: statistics::Group(&c), cache(c),
ADD_STAT(demandHits, Stats::units::Count::get(),
ADD_STAT(demandHits, statistics::units::Count::get(),
"number of demand (read+write) hits"),
ADD_STAT(overallHits, Stats::units::Count::get(),
ADD_STAT(overallHits, statistics::units::Count::get(),
"number of overall hits"),
ADD_STAT(demandMisses, Stats::units::Count::get(),
ADD_STAT(demandMisses, statistics::units::Count::get(),
"number of demand (read+write) misses"),
ADD_STAT(overallMisses, Stats::units::Count::get(),
ADD_STAT(overallMisses, statistics::units::Count::get(),
"number of overall misses"),
ADD_STAT(demandMissLatency, Stats::units::Tick::get(),
ADD_STAT(demandMissLatency, statistics::units::Tick::get(),
"number of demand (read+write) miss ticks"),
ADD_STAT(overallMissLatency, Stats::units::Tick::get(),
ADD_STAT(overallMissLatency, statistics::units::Tick::get(),
"number of overall miss ticks"),
ADD_STAT(demandAccesses, Stats::units::Count::get(),
ADD_STAT(demandAccesses, statistics::units::Count::get(),
"number of demand (read+write) accesses"),
ADD_STAT(overallAccesses, Stats::units::Count::get(),
ADD_STAT(overallAccesses, statistics::units::Count::get(),
"number of overall (read+write) accesses"),
ADD_STAT(demandMissRate, Stats::units::Ratio::get(),
ADD_STAT(demandMissRate, statistics::units::Ratio::get(),
"miss rate for demand accesses"),
ADD_STAT(overallMissRate, Stats::units::Ratio::get(),
ADD_STAT(overallMissRate, statistics::units::Ratio::get(),
"miss rate for overall accesses"),
ADD_STAT(demandAvgMissLatency, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(demandAvgMissLatency, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average overall miss latency"),
ADD_STAT(overallAvgMissLatency, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(overallAvgMissLatency, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average overall miss latency"),
ADD_STAT(blockedCycles, Stats::units::Cycle::get(),
ADD_STAT(blockedCycles, statistics::units::Cycle::get(),
"number of cycles access was blocked"),
ADD_STAT(blockedCauses, Stats::units::Count::get(),
ADD_STAT(blockedCauses, statistics::units::Count::get(),
"number of times access was blocked"),
ADD_STAT(avgBlocked, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(avgBlocked, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average number of cycles each access was blocked"),
ADD_STAT(unusedPrefetches, Stats::units::Count::get(),
ADD_STAT(unusedPrefetches, statistics::units::Count::get(),
"number of HardPF blocks evicted w/o reference"),
ADD_STAT(writebacks, Stats::units::Count::get(), "number of writebacks"),
ADD_STAT(demandMshrHits, Stats::units::Count::get(),
ADD_STAT(writebacks, statistics::units::Count::get(), "number of writebacks"),
ADD_STAT(demandMshrHits, statistics::units::Count::get(),
"number of demand (read+write) MSHR hits"),
ADD_STAT(overallMshrHits, Stats::units::Count::get(),
ADD_STAT(overallMshrHits, statistics::units::Count::get(),
"number of overall MSHR hits"),
ADD_STAT(demandMshrMisses, Stats::units::Count::get(),
ADD_STAT(demandMshrMisses, statistics::units::Count::get(),
"number of demand (read+write) MSHR misses"),
ADD_STAT(overallMshrMisses, Stats::units::Count::get(),
ADD_STAT(overallMshrMisses, statistics::units::Count::get(),
"number of overall MSHR misses"),
ADD_STAT(overallMshrUncacheable, Stats::units::Count::get(),
ADD_STAT(overallMshrUncacheable, statistics::units::Count::get(),
"number of overall MSHR uncacheable misses"),
ADD_STAT(demandMshrMissLatency, Stats::units::Tick::get(),
ADD_STAT(demandMshrMissLatency, statistics::units::Tick::get(),
"number of demand (read+write) MSHR miss ticks"),
ADD_STAT(overallMshrMissLatency, Stats::units::Tick::get(),
ADD_STAT(overallMshrMissLatency, statistics::units::Tick::get(),
"number of overall MSHR miss ticks"),
ADD_STAT(overallMshrUncacheableLatency, Stats::units::Tick::get(),
ADD_STAT(overallMshrUncacheableLatency, statistics::units::Tick::get(),
"number of overall MSHR uncacheable ticks"),
ADD_STAT(demandMshrMissRate, Stats::units::Ratio::get(),
ADD_STAT(demandMshrMissRate, statistics::units::Ratio::get(),
"mshr miss ratio for demand accesses"),
ADD_STAT(overallMshrMissRate, Stats::units::Ratio::get(),
ADD_STAT(overallMshrMissRate, statistics::units::Ratio::get(),
"mshr miss ratio for overall accesses"),
ADD_STAT(demandAvgMshrMissLatency, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(demandAvgMshrMissLatency, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average overall mshr miss latency"),
ADD_STAT(overallAvgMshrMissLatency, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(overallAvgMshrMissLatency, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average overall mshr miss latency"),
ADD_STAT(overallAvgMshrUncacheableLatency, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
ADD_STAT(overallAvgMshrUncacheableLatency, statistics::units::Rate<
statistics::units::Cycle, statistics::units::Count>::get(),
"average overall mshr uncacheable latency"),
ADD_STAT(replacements, Stats::units::Count::get(),
ADD_STAT(replacements, statistics::units::Count::get(),
"number of replacements"),
ADD_STAT(dataExpansions, Stats::units::Count::get(),
ADD_STAT(dataExpansions, statistics::units::Count::get(),
"number of data expansions"),
ADD_STAT(dataContractions, Stats::units::Count::get(),
ADD_STAT(dataContractions, statistics::units::Count::get(),
"number of data contractions"),
cmd(MemCmd::NUM_MEM_CMDS)
{
@@ -2170,9 +2170,9 @@ BaseCache::CacheStats::CacheStats(BaseCache &c)
void
BaseCache::CacheStats::regStats()
{
using namespace Stats;
using namespace statistics;
Stats::Group::regStats();
statistics::Group::regStats();
System *system = cache.system;
const auto max_requestors = system->maxRequestors();

98
src/mem/cache/base.hh vendored
View File

@@ -982,7 +982,7 @@ class BaseCache : public ClockedObject
/** System we are currently operating in. */
System *system;
struct CacheCmdStats : public Stats::Group
struct CacheCmdStats : public statistics::Group
{
CacheCmdStats(BaseCache &c, const std::string &name);
@@ -998,40 +998,40 @@ class BaseCache : public ClockedObject
/** Number of hits per thread for each type of command.
@sa Packet::Command */
Stats::Vector hits;
statistics::Vector hits;
/** Number of misses per thread for each type of command.
@sa Packet::Command */
Stats::Vector misses;
statistics::Vector misses;
/**
* Total number of cycles per thread/command spent waiting for a miss.
* Used to calculate the average miss latency.
*/
Stats::Vector missLatency;
statistics::Vector missLatency;
/** The number of accesses per command and thread. */
Stats::Formula accesses;
statistics::Formula accesses;
/** The miss rate per command and thread. */
Stats::Formula missRate;
statistics::Formula missRate;
/** The average miss latency per command and thread. */
Stats::Formula avgMissLatency;
statistics::Formula avgMissLatency;
/** Number of misses that hit in the MSHRs per command and thread. */
Stats::Vector mshrHits;
statistics::Vector mshrHits;
/** Number of misses that miss in the MSHRs, per command and thread. */
Stats::Vector mshrMisses;
statistics::Vector mshrMisses;
/** Number of misses that miss in the MSHRs, per command and thread. */
Stats::Vector mshrUncacheable;
statistics::Vector mshrUncacheable;
/** Total cycle latency of each MSHR miss, per command and thread. */
Stats::Vector mshrMissLatency;
statistics::Vector mshrMissLatency;
/** Total cycle latency of each MSHR miss, per command and thread. */
Stats::Vector mshrUncacheableLatency;
statistics::Vector mshrUncacheableLatency;
/** The miss rate in the MSHRs pre command and thread. */
Stats::Formula mshrMissRate;
statistics::Formula mshrMissRate;
/** The average latency of an MSHR miss, per command and thread. */
Stats::Formula avgMshrMissLatency;
statistics::Formula avgMshrMissLatency;
/** The average latency of an MSHR miss, per command and thread. */
Stats::Formula avgMshrUncacheableLatency;
statistics::Formula avgMshrUncacheableLatency;
};
struct CacheStats : public Stats::Group
struct CacheStats : public statistics::Group
{
CacheStats(BaseCache &c);
@@ -1044,95 +1044,95 @@ class BaseCache : public ClockedObject
const BaseCache &cache;
/** Number of hits for demand accesses. */
Stats::Formula demandHits;
statistics::Formula demandHits;
/** Number of hit for all accesses. */
Stats::Formula overallHits;
statistics::Formula overallHits;
/** Number of misses for demand accesses. */
Stats::Formula demandMisses;
statistics::Formula demandMisses;
/** Number of misses for all accesses. */
Stats::Formula overallMisses;
statistics::Formula overallMisses;
/** Total number of cycles spent waiting for demand misses. */
Stats::Formula demandMissLatency;
statistics::Formula demandMissLatency;
/** Total number of cycles spent waiting for all misses. */
Stats::Formula overallMissLatency;
statistics::Formula overallMissLatency;
/** The number of demand accesses. */
Stats::Formula demandAccesses;
statistics::Formula demandAccesses;
/** The number of overall accesses. */
Stats::Formula overallAccesses;
statistics::Formula overallAccesses;
/** The miss rate of all demand accesses. */
Stats::Formula demandMissRate;
statistics::Formula demandMissRate;
/** The miss rate for all accesses. */
Stats::Formula overallMissRate;
statistics::Formula overallMissRate;
/** The average miss latency for demand misses. */
Stats::Formula demandAvgMissLatency;
statistics::Formula demandAvgMissLatency;
/** The average miss latency for all misses. */
Stats::Formula overallAvgMissLatency;
statistics::Formula overallAvgMissLatency;
/** The total number of cycles blocked for each blocked cause. */
Stats::Vector blockedCycles;
statistics::Vector blockedCycles;
/** The number of times this cache blocked for each blocked cause. */
Stats::Vector blockedCauses;
statistics::Vector blockedCauses;
/** The average number of cycles blocked for each blocked cause. */
Stats::Formula avgBlocked;
statistics::Formula avgBlocked;
/** The number of times a HW-prefetched block is evicted w/o
* reference. */
Stats::Scalar unusedPrefetches;
statistics::Scalar unusedPrefetches;
/** Number of blocks written back per thread. */
Stats::Vector writebacks;
statistics::Vector writebacks;
/** Demand misses that hit in the MSHRs. */
Stats::Formula demandMshrHits;
statistics::Formula demandMshrHits;
/** Total number of misses that hit in the MSHRs. */
Stats::Formula overallMshrHits;
statistics::Formula overallMshrHits;
/** Demand misses that miss in the MSHRs. */
Stats::Formula demandMshrMisses;
statistics::Formula demandMshrMisses;
/** Total number of misses that miss in the MSHRs. */
Stats::Formula overallMshrMisses;
statistics::Formula overallMshrMisses;
/** Total number of misses that miss in the MSHRs. */
Stats::Formula overallMshrUncacheable;
statistics::Formula overallMshrUncacheable;
/** Total cycle latency of demand MSHR misses. */
Stats::Formula demandMshrMissLatency;
statistics::Formula demandMshrMissLatency;
/** Total cycle latency of overall MSHR misses. */
Stats::Formula overallMshrMissLatency;
statistics::Formula overallMshrMissLatency;
/** Total cycle latency of overall MSHR misses. */
Stats::Formula overallMshrUncacheableLatency;
statistics::Formula overallMshrUncacheableLatency;
/** The demand miss rate in the MSHRs. */
Stats::Formula demandMshrMissRate;
statistics::Formula demandMshrMissRate;
/** The overall miss rate in the MSHRs. */
Stats::Formula overallMshrMissRate;
statistics::Formula overallMshrMissRate;
/** The average latency of a demand MSHR miss. */
Stats::Formula demandAvgMshrMissLatency;
statistics::Formula demandAvgMshrMissLatency;
/** The average overall latency of an MSHR miss. */
Stats::Formula overallAvgMshrMissLatency;
statistics::Formula overallAvgMshrMissLatency;
/** The average overall latency of an MSHR miss. */
Stats::Formula overallAvgMshrUncacheableLatency;
statistics::Formula overallAvgMshrUncacheableLatency;
/** Number of replacements of valid blocks. */
Stats::Scalar replacements;
statistics::Scalar replacements;
/** Number of data expansions. */
Stats::Scalar dataExpansions;
statistics::Scalar dataExpansions;
/**
* Number of data contractions (blocks that had their compression
* factor improved).
*/
Stats::Scalar dataContractions;
statistics::Scalar dataContractions;
/** Per-command statistics */
std::vector<std::unique_ptr<CacheCmdStats>> cmd;

21
src/mem/cache/compressors/base.cc vendored
View File

@@ -229,20 +229,20 @@ Base::setSizeBits(CacheBlk* blk, const std::size_t size_bits)
}
Base::BaseStats::BaseStats(Base& _compressor)
: Stats::Group(&_compressor), compressor(_compressor),
ADD_STAT(compressions, Stats::units::Count::get(),
: statistics::Group(&_compressor), compressor(_compressor),
ADD_STAT(compressions, statistics::units::Count::get(),
"Total number of compressions"),
ADD_STAT(failedCompressions, Stats::units::Count::get(),
ADD_STAT(failedCompressions, statistics::units::Count::get(),
"Total number of failed compressions"),
ADD_STAT(compressionSize, Stats::units::Count::get(),
ADD_STAT(compressionSize, statistics::units::Count::get(),
"Number of blocks that were compressed to this power of two "
"size"),
ADD_STAT(compressionSizeBits, Stats::units::Bit::get(),
ADD_STAT(compressionSizeBits, statistics::units::Bit::get(),
"Total compressed data size"),
ADD_STAT(avgCompressionSizeBits, Stats::units::Rate<
Stats::units::Bit, Stats::units::Count>::get(),
ADD_STAT(avgCompressionSizeBits, statistics::units::Rate<
statistics::units::Bit, statistics::units::Count>::get(),
"Average compression size"),
ADD_STAT(decompressions, Stats::units::Count::get(),
ADD_STAT(decompressions, statistics::units::Count::get(),
"Total number of decompressions")
{
}
@@ -250,7 +250,7 @@ Base::BaseStats::BaseStats(Base& _compressor)
void
Base::BaseStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
// Values comprised are {0, 1, 2, 4, ..., blkSize}
compressionSize.init(std::log2(compressor.blkSize*8) + 2);
@@ -264,7 +264,8 @@ Base::BaseStats::regStats()
"Number of blocks that compressed to fit in " + str_i + " bits");
}
avgCompressionSizeBits.flags(Stats::total | Stats::nozero | Stats::nonan);
avgCompressionSizeBits.flags(statistics::total | statistics::nozero |
statistics::nonan);
avgCompressionSizeBits = compressionSizeBits / compressions;
}

14
src/mem/cache/compressors/base.hh vendored
View File

@@ -126,7 +126,7 @@ class Base : public SimObject
/** Pointer to the parent cache. */
BaseCache* cache;
struct BaseStats : public Stats::Group
struct BaseStats : public statistics::Group
{
const Base& compressor;
@@ -135,22 +135,22 @@ class Base : public SimObject
void regStats() override;
/** Number of compressions performed. */
Stats::Scalar compressions;
statistics::Scalar compressions;
/** Number of failed compressions. */
Stats::Scalar failedCompressions;
statistics::Scalar failedCompressions;
/** Number of blocks that were compressed to this power of two size. */
Stats::Vector compressionSize;
statistics::Vector compressionSize;
/** Total compressed data size, in number of bits. */
Stats::Scalar compressionSizeBits;
statistics::Scalar compressionSizeBits;
/** Average data size after compression, in number of bits. */
Stats::Formula avgCompressionSizeBits;
statistics::Formula avgCompressionSizeBits;
/** Number of decompressions performed. */
Stats::Scalar decompressions;
statistics::Scalar decompressions;
} stats;
/**

6
src/mem/cache/compressors/base_dictionary_compressor.cc vendored
View File

@@ -46,8 +46,8 @@ BaseDictionaryCompressor::BaseDictionaryCompressor(const Params &p)
BaseDictionaryCompressor::DictionaryStats::DictionaryStats(
BaseStats& base_group, BaseDictionaryCompressor& _compressor)
: Stats::Group(&base_group), compressor(_compressor),
ADD_STAT(patterns, Stats::units::Count::get(),
: statistics::Group(&base_group), compressor(_compressor),
ADD_STAT(patterns, statistics::units::Count::get(),
"Number of data entries that were compressed to this pattern")
{
}
@@ -55,7 +55,7 @@ BaseDictionaryCompressor::DictionaryStats::DictionaryStats(
void
BaseDictionaryCompressor::DictionaryStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
// We store the frequency of each pattern
patterns.init(compressor.getNumPatterns());

4
src/mem/cache/compressors/dictionary_compressor.hh vendored
View File

@@ -71,7 +71,7 @@ class BaseDictionaryCompressor : public Base
/** Number of valid entries in the dictionary. */
std::size_t numEntries;
struct DictionaryStats : public Stats::Group
struct DictionaryStats : public statistics::Group
{
const BaseDictionaryCompressor& compressor;
@@ -81,7 +81,7 @@ class BaseDictionaryCompressor : public Base
void regStats() override;
/** Number of data entries that were compressed to each pattern. */
Stats::Vector patterns;
statistics::Vector patterns;
} dictionaryStats;
/**

6
src/mem/cache/compressors/multi.cc vendored
View File

@@ -189,8 +189,8 @@ Multi::decompress(const CompressionData* comp_data,
}
Multi::MultiStats::MultiStats(BaseStats& base_group, Multi& _compressor)
: Stats::Group(&base_group), compressor(_compressor),
ADD_STAT(ranks, Stats::units::Count::get(),
: statistics::Group(&base_group), compressor(_compressor),
ADD_STAT(ranks, statistics::units::Count::get(),
"Number of times each compressor had the nth best compression")
{
}
@@ -198,7 +198,7 @@ Multi::MultiStats::MultiStats(BaseStats& base_group, Multi& _compressor)
void
Multi::MultiStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
const std::size_t num_compressors = compressor.compressors.size();
ranks.init(num_compressors, num_compressors);

4
src/mem/cache/compressors/multi.hh vendored
View File

@@ -84,7 +84,7 @@ class Multi : public Base
*/
const Cycles extraDecompressionLatency;
struct MultiStats : public Stats::Group
struct MultiStats : public statistics::Group
{
const Multi& compressor;
@@ -95,7 +95,7 @@ class Multi : public Base
/**
* Number of times each compressor provided the nth best compression.
*/
Stats::Vector2d ranks;
statistics::Vector2d ranks;
} multiStats;
public:

8
src/mem/cache/prefetch/base.cc vendored
View File

@@ -113,9 +113,11 @@ Base::setCache(BaseCache *_cache)
blkSize = cache->getBlockSize();
lBlkSize = floorLog2(blkSize);
}
Base::StatGroup::StatGroup(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(pfIssued, Stats::units::Count::get(), "number of hwpf issued")
Base::StatGroup::StatGroup(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(pfIssued, statistics::units::Count::get(),
"number of hwpf issued")
{
}

6
src/mem/cache/prefetch/base.hh vendored
View File

@@ -321,10 +321,10 @@ class Base : public ClockedObject
Addr pageOffset(Addr a) const;
/** Build the address of the i-th block inside the page */
Addr pageIthBlockAddress(Addr page, uint32_t i) const;
struct StatGroup : public Stats::Group
struct StatGroup : public statistics::Group
{
StatGroup(Stats::Group *parent);
Stats::Scalar pfIssued;
StatGroup(statistics::Group *parent);
statistics::Scalar pfIssued;
} prefetchStats;
/** Total prefetches issued */

15
src/mem/cache/prefetch/queued.cc vendored
View File

@@ -226,17 +226,18 @@ Queued::getPacket()
processMissingTranslations(queueSize - pfq.size());
return pkt;
}
Queued::QueuedStats::QueuedStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(pfIdentified, Stats::units::Count::get(),
Queued::QueuedStats::QueuedStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(pfIdentified, statistics::units::Count::get(),
"number of prefetch candidates identified"),
ADD_STAT(pfBufferHit, Stats::units::Count::get(),
ADD_STAT(pfBufferHit, statistics::units::Count::get(),
"number of redundant prefetches already in prefetch queue"),
ADD_STAT(pfInCache, Stats::units::Count::get(),
ADD_STAT(pfInCache, statistics::units::Count::get(),
"number of redundant prefetches already in cache/mshr dropped"),
ADD_STAT(pfRemovedFull, Stats::units::Count::get(),
ADD_STAT(pfRemovedFull, statistics::units::Count::get(),
"number of prefetches dropped due to prefetch queue size"),
ADD_STAT(pfSpanPage, Stats::units::Count::get(),
ADD_STAT(pfSpanPage, statistics::units::Count::get(),
"number of prefetches that crossed the page")
{
}

14
src/mem/cache/prefetch/queued.hh vendored
View File

@@ -171,15 +171,15 @@ class Queued : public Base
/** Percentage of requests that can be throttled */
const unsigned int throttleControlPct;
struct QueuedStats : public Stats::Group
struct QueuedStats : public statistics::Group
{
QueuedStats(Stats::Group *parent);
QueuedStats(statistics::Group *parent);
// STATS
Stats::Scalar pfIdentified;
Stats::Scalar pfBufferHit;
Stats::Scalar pfInCache;
Stats::Scalar pfRemovedFull;
Stats::Scalar pfSpanPage;
statistics::Scalar pfIdentified;
statistics::Scalar pfBufferHit;
statistics::Scalar pfInCache;
statistics::Scalar pfRemovedFull;
statistics::Scalar pfSpanPage;
} statsQueued;
public:
using AddrPriority = std::pair<Addr, int32_t>;

44
src/mem/cache/tags/base.cc vendored
View File

@@ -213,36 +213,36 @@ BaseTags::print()
}
BaseTags::BaseTagStats::BaseTagStats(BaseTags &_tags)
: Stats::Group(&_tags),
: statistics::Group(&_tags),
tags(_tags),
ADD_STAT(tagsInUse, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(tagsInUse, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average ticks per tags in use"),
ADD_STAT(totalRefs, Stats::units::Count::get(),
ADD_STAT(totalRefs, statistics::units::Count::get(),
"Total number of references to valid blocks."),
ADD_STAT(sampledRefs, Stats::units::Count::get(),
ADD_STAT(sampledRefs, statistics::units::Count::get(),
"Sample count of references to valid blocks."),
ADD_STAT(avgRefs, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
ADD_STAT(avgRefs, statistics::units::Rate<
statistics::units::Count, statistics::units::Count>::get(),
"Average number of references to valid blocks."),
ADD_STAT(warmupTick, Stats::units::Tick::get(),
ADD_STAT(warmupTick, statistics::units::Tick::get(),
"The tick when the warmup percentage was hit."),
ADD_STAT(occupancies, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(occupancies, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average occupied blocks per tick, per requestor"),
ADD_STAT(avgOccs, Stats::units::Rate<
Stats::units::Ratio, Stats::units::Tick>::get(),
ADD_STAT(avgOccs, statistics::units::Rate<
statistics::units::Ratio, statistics::units::Tick>::get(),
"Average percentage of cache occupancy"),
ADD_STAT(occupanciesTaskId, Stats::units::Count::get(),
ADD_STAT(occupanciesTaskId, statistics::units::Count::get(),
"Occupied blocks per task id"),
ADD_STAT(ageTaskId, Stats::units::Count::get(),
ADD_STAT(ageTaskId, statistics::units::Count::get(),
"Occupied blocks per task id, per block age"),
ADD_STAT(ratioOccsTaskId, Stats::units::Ratio::get(),
ADD_STAT(ratioOccsTaskId, statistics::units::Ratio::get(),
"Ratio of occupied blocks and all blocks, per task id"),
ADD_STAT(tagAccesses, Stats::units::Count::get(),
ADD_STAT(tagAccesses, statistics::units::Count::get(),
"Number of tag accesses"),
ADD_STAT(dataAccesses, Stats::units::Count::get(),
ADD_STAT(dataAccesses, statistics::units::Count::get(),
"Number of data accesses")
{
}
@@ -250,9 +250,9 @@ BaseTags::BaseTagStats::BaseTagStats(BaseTags &_tags)
void
BaseTags::BaseTagStats::regStats()
{
using namespace Stats;
using namespace statistics;
Stats::Group::regStats();
statistics::Group::regStats();
System *system = tags.system;
@@ -271,7 +271,7 @@ BaseTags::BaseTagStats::regStats()
avgOccs.subname(i, system->getRequestorName(i));
}
avgOccs = occupancies / Stats::constant(tags.numBlocks);
avgOccs = occupancies / statistics::constant(tags.numBlocks);
occupanciesTaskId
.init(context_switch_task_id::NumTaskId)
@@ -285,13 +285,13 @@ BaseTags::BaseTagStats::regStats()
ratioOccsTaskId.flags(nozero);
ratioOccsTaskId = occupanciesTaskId / Stats::constant(tags.numBlocks);
ratioOccsTaskId = occupanciesTaskId / statistics::constant(tags.numBlocks);
}
void
BaseTags::BaseTagStats::preDumpStats()
{
Stats::Group::preDumpStats();
statistics::Group::preDumpStats();
tags.computeStats();
}

26
src/mem/cache/tags/base.hh vendored
View File

@@ -102,7 +102,7 @@ class BaseTags : public ClockedObject
/**
* TODO: It would be good if these stats were acquired after warmup.
*/
struct BaseTagStats : public Stats::Group
struct BaseTagStats : public statistics::Group
{
BaseTagStats(BaseTags &tags);
@@ -112,46 +112,46 @@ class BaseTags : public ClockedObject
BaseTags &tags;
/** Per tick average of the number of tags that hold valid data. */
Stats::Average tagsInUse;
statistics::Average tagsInUse;
/** The total number of references to a block before it is replaced. */
Stats::Scalar totalRefs;
statistics::Scalar totalRefs;
/**
* The number of reference counts sampled. This is different
* from replacements because we sample all the valid blocks
* when the simulator exits.
*/
Stats::Scalar sampledRefs;
statistics::Scalar sampledRefs;
/**
* Average number of references to a block before is was replaced.
* @todo This should change to an average stat once we have them.
*/
Stats::Formula avgRefs;
statistics::Formula avgRefs;
/** The tick that the warmup percentage was hit. 0 on failure. */
Stats::Scalar warmupTick;
statistics::Scalar warmupTick;
/** Average occupancy of each requestor using the cache */
Stats::AverageVector occupancies;
statistics::AverageVector occupancies;
/** Average occ % of each requestor using the cache */
Stats::Formula avgOccs;
statistics::Formula avgOccs;
/** Occupancy of each context/cpu using the cache */
Stats::Vector occupanciesTaskId;
statistics::Vector occupanciesTaskId;
/** Occupancy of each context/cpu using the cache */
Stats::Vector2d ageTaskId;
statistics::Vector2d ageTaskId;
/** Occ ratio of each context/cpu using the cache */
Stats::Formula ratioOccsTaskId;
statistics::Formula ratioOccsTaskId;
/** Number of tags consulted over all accesses. */
Stats::Scalar tagAccesses;
statistics::Scalar tagAccesses;
/** Number of data blocks consulted over all accesses. */
Stats::Scalar dataAccesses;
statistics::Scalar dataAccesses;
} stats;
public:

10
src/mem/cache/tags/fa_lru.cc vendored
View File

@@ -292,19 +292,19 @@ printSize(std::ostream &stream, size_t size)
}
FALRU::CacheTracking::CacheTracking(unsigned min_size, unsigned max_size,
unsigned block_size, Stats::Group *parent)
: Stats::Group(parent),
unsigned block_size, statistics::Group *parent)
: statistics::Group(parent),
blkSize(block_size),
minTrackedSize(min_size),
numTrackedCaches(max_size > min_size ?
floorLog2(max_size) - floorLog2(min_size) : 0),
inAllCachesMask(mask(numTrackedCaches)),
boundaries(numTrackedCaches),
ADD_STAT(hits, Stats::units::Count::get(),
ADD_STAT(hits, statistics::units::Count::get(),
"The number of hits in each cache size."),
ADD_STAT(misses, Stats::units::Count::get(),
ADD_STAT(misses, statistics::units::Count::get(),
"The number of misses in each cache size."),
ADD_STAT(accesses, Stats::units::Count::get(),
ADD_STAT(accesses, statistics::units::Count::get(),
"The number of accesses to the FA LRU cache.")
{
fatal_if(numTrackedCaches > sizeof(CachesMask) * 8,

10
src/mem/cache/tags/fa_lru.hh vendored
View File

@@ -273,11 +273,11 @@ class FALRU : public BaseTags
* caches from a set minimum size of interest up to the actual
* cache size.
*/
class CacheTracking : public Stats::Group
class CacheTracking : public statistics::Group
{
public:
CacheTracking(unsigned min_size, unsigned max_size,
unsigned block_size, Stats::Group *parent);
unsigned block_size, statistics::Group *parent);
/**
* Initialiaze cache blocks and the tracking mechanism
@@ -356,11 +356,11 @@ class FALRU : public BaseTags
*/
/** Hits in each cache */
Stats::Vector hits;
statistics::Vector hits;
/** Misses in each cache */
Stats::Vector misses;
statistics::Vector misses;
/** Total number of accesses */
Stats::Scalar accesses;
statistics::Scalar accesses;
/**
* @}

6
src/mem/cache/tags/sector_tags.cc vendored
View File

@@ -337,8 +337,8 @@ SectorTags::regenerateBlkAddr(const CacheBlk* blk) const
SectorTags::SectorTagsStats::SectorTagsStats(BaseTagStats &base_group,
SectorTags& _tags)
: Stats::Group(&base_group), tags(_tags),
ADD_STAT(evictionsReplacement, Stats::units::Count::get(),
: statistics::Group(&base_group), tags(_tags),
ADD_STAT(evictionsReplacement, statistics::units::Count::get(),
"Number of blocks evicted due to a replacement")
{
}
@@ -346,7 +346,7 @@ SectorTags::SectorTagsStats::SectorTagsStats(BaseTagStats &base_group,
void
SectorTags::SectorTagsStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
evictionsReplacement.init(tags.numBlocksPerSector + 1);
for (unsigned i = 0; i <= tags.numBlocksPerSector; ++i) {

4
src/mem/cache/tags/sector_tags.hh vendored
View File

@@ -91,7 +91,7 @@ class SectorTags : public BaseTags
/** Mask out all bits that aren't part of the sector tag. */
const unsigned sectorMask;
struct SectorTagsStats : public Stats::Group
struct SectorTagsStats : public statistics::Group
{
const SectorTags& tags;
@@ -100,7 +100,7 @@ class SectorTags : public BaseTags
void regStats() override;
/** Number of sub-blocks evicted due to a replacement. */
Stats::Vector evictionsReplacement;
statistics::Vector evictionsReplacement;
} sectorStats;
public:

6
src/mem/coherent_xbar.cc
View File

@@ -60,9 +60,9 @@ CoherentXBar::CoherentXBar(const CoherentXBarParams &p)
pointOfCoherency(p.point_of_coherency),
pointOfUnification(p.point_of_unification),
ADD_STAT(snoops, Stats::units::Count::get(), "Total snoops"),
ADD_STAT(snoopTraffic, Stats::units::Byte::get(), "Total snoop traffic"),
ADD_STAT(snoopFanout, Stats::units::Count::get(),
ADD_STAT(snoops, statistics::units::Count::get(), "Total snoops"),
ADD_STAT(snoopTraffic, statistics::units::Byte::get(), "Total snoop traffic"),
ADD_STAT(snoopFanout, statistics::units::Count::get(),
"Request fanout histogram")
{
// create the ports based on the size of the memory-side port and

6
src/mem/coherent_xbar.hh
View File

@@ -415,9 +415,9 @@ class CoherentXBar : public BaseXBar
(pkt->req->isToPOU() && pointOfUnification);
}
Stats::Scalar snoops;
Stats::Scalar snoopTraffic;
Stats::Distribution snoopFanout;
statistics::Scalar snoops;
statistics::Scalar snoopTraffic;
statistics::Distribution snoopFanout;
public:

54
src/mem/comm_monitor.cc
View File

@@ -96,80 +96,80 @@ CommMonitor::recvFunctionalSnoop(PacketPtr pkt)
cpuSidePort.sendFunctionalSnoop(pkt);
}
CommMonitor::MonitorStats::MonitorStats(Stats::Group *parent,
CommMonitor::MonitorStats::MonitorStats(statistics::Group *parent,
const CommMonitorParams &params)
: Stats::Group(parent),
: statistics::Group(parent),
disableBurstLengthHists(params.disable_burst_length_hists),
ADD_STAT(readBurstLengthHist, Stats::units::Byte::get(),
ADD_STAT(readBurstLengthHist, statistics::units::Byte::get(),
"Histogram of burst lengths of transmitted packets"),
ADD_STAT(writeBurstLengthHist, Stats::units::Byte::get(),
ADD_STAT(writeBurstLengthHist, statistics::units::Byte::get(),
"Histogram of burst lengths of transmitted packets"),
disableBandwidthHists(params.disable_bandwidth_hists),
readBytes(0),
ADD_STAT(readBandwidthHist, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(readBandwidthHist, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Histogram of read bandwidth per sample period"),
ADD_STAT(totalReadBytes, Stats::units::Byte::get(),
ADD_STAT(totalReadBytes, statistics::units::Byte::get(),
"Number of bytes read"),
ADD_STAT(averageReadBandwidth, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(averageReadBandwidth, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average read bandwidth",
totalReadBytes / simSeconds),
writtenBytes(0),
ADD_STAT(writeBandwidthHist, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(writeBandwidthHist, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Histogram of write bandwidth"),
ADD_STAT(totalWrittenBytes, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(totalWrittenBytes, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Number of bytes written"),
ADD_STAT(averageWriteBandwidth, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(averageWriteBandwidth, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average write bandwidth",
totalWrittenBytes / simSeconds),
disableLatencyHists(params.disable_latency_hists),
ADD_STAT(readLatencyHist, Stats::units::Tick::get(),
ADD_STAT(readLatencyHist, statistics::units::Tick::get(),
"Read request-response latency"),
ADD_STAT(writeLatencyHist, Stats::units::Tick::get(),
ADD_STAT(writeLatencyHist, statistics::units::Tick::get(),
"Write request-response latency"),
disableITTDists(params.disable_itt_dists),
ADD_STAT(ittReadRead, Stats::units::Tick::get(),
ADD_STAT(ittReadRead, statistics::units::Tick::get(),
"Read-to-read inter transaction time"),
ADD_STAT(ittWriteWrite, Stats::units::Tick::get(),
ADD_STAT(ittWriteWrite, statistics::units::Tick::get(),
"Write-to-write inter transaction time"),
ADD_STAT(ittReqReq, Stats::units::Tick::get(),
ADD_STAT(ittReqReq, statistics::units::Tick::get(),
"Request-to-request inter transaction time"),
timeOfLastRead(0), timeOfLastWrite(0), timeOfLastReq(0),
disableOutstandingHists(params.disable_outstanding_hists),
ADD_STAT(outstandingReadsHist, Stats::units::Count::get(),
ADD_STAT(outstandingReadsHist, statistics::units::Count::get(),
"Outstanding read transactions"),
outstandingReadReqs(0),
ADD_STAT(outstandingWritesHist, Stats::units::Count::get(),
ADD_STAT(outstandingWritesHist, statistics::units::Count::get(),
"Outstanding write transactions"),
outstandingWriteReqs(0),
disableTransactionHists(params.disable_transaction_hists),
ADD_STAT(readTransHist, Stats::units::Count::get(),
ADD_STAT(readTransHist, statistics::units::Count::get(),
"Histogram of read transactions per sample period"),
readTrans(0),
ADD_STAT(writeTransHist, Stats::units::Count::get(),
ADD_STAT(writeTransHist, statistics::units::Count::get(),
"Histogram of write transactions per sample period"),
writeTrans(0),
disableAddrDists(params.disable_addr_dists),
readAddrMask(params.read_addr_mask),
writeAddrMask(params.write_addr_mask),
ADD_STAT(readAddrDist, Stats::units::Count::get(),
ADD_STAT(readAddrDist, statistics::units::Count::get(),
"Read address distribution"),
ADD_STAT(writeAddrDist, Stats::units::Count::get(),
ADD_STAT(writeAddrDist, statistics::units::Count::get(),
"Write address distribution")
{
using namespace Stats;
using namespace statistics;
readBurstLengthHist
.init(params.burst_length_bins)

43
src/mem/comm_monitor.hh
View File

@@ -267,16 +267,16 @@ class CommMonitor : public SimObject
bool tryTiming(PacketPtr pkt);
/** Stats declarations, all in a struct for convenience. */
struct MonitorStats : public Stats::Group
struct MonitorStats : public statistics::Group
{
/** Disable flag for burst length histograms **/
bool disableBurstLengthHists;
/** Histogram of read burst lengths */
Stats::Histogram readBurstLengthHist;
statistics::Histogram readBurstLengthHist;
/** Histogram of write burst lengths */
Stats::Histogram writeBurstLengthHist;
statistics::Histogram writeBurstLengthHist;
/** Disable flag for the bandwidth histograms */
bool disableBandwidthHists;
@@ -286,27 +286,27 @@ class CommMonitor : public SimObject
* internal counter is an unsigned int rather than a stat.
*/
unsigned int readBytes;
Stats::Histogram readBandwidthHist;
Stats::Scalar totalReadBytes;
Stats::Formula averageReadBandwidth;
statistics::Histogram readBandwidthHist;
statistics::Scalar totalReadBytes;
statistics::Formula averageReadBandwidth;
/**
* Histogram for write bandwidth per sample window. The
* internal counter is an unsigned int rather than a stat.
*/
unsigned int writtenBytes;
Stats::Histogram writeBandwidthHist;
Stats::Scalar totalWrittenBytes;
Stats::Formula averageWriteBandwidth;
statistics::Histogram writeBandwidthHist;
statistics::Scalar totalWrittenBytes;
statistics::Formula averageWriteBandwidth;
/** Disable flag for latency histograms. */
bool disableLatencyHists;
/** Histogram of read request-to-response latencies */
Stats::Histogram readLatencyHist;
statistics::Histogram readLatencyHist;
/** Histogram of write request-to-response latencies */
Stats::Histogram writeLatencyHist;
statistics::Histogram writeLatencyHist;
/** Disable flag for ITT distributions. */
bool disableITTDists;
@@ -317,9 +317,9 @@ class CommMonitor : public SimObject
* accesses. The time of a request is the tick at which the
* request is forwarded by the monitor.
*/
Stats::Distribution ittReadRead;
Stats::Distribution ittWriteWrite;
Stats::Distribution ittReqReq;
statistics::Distribution ittReadRead;
statistics::Distribution ittWriteWrite;
statistics::Distribution ittReqReq;
Tick timeOfLastRead;
Tick timeOfLastWrite;
Tick timeOfLastReq;
@@ -332,7 +332,7 @@ class CommMonitor : public SimObject
* outstanding read requests is an unsigned integer because
* it should not be reset when stats are reset.
*/
Stats::Histogram outstandingReadsHist;
statistics::Histogram outstandingReadsHist;
unsigned int outstandingReadReqs;
/**
@@ -340,18 +340,18 @@ class CommMonitor : public SimObject
* outstanding write requests is an unsigned integer because
* it should not be reset when stats are reset.
*/
Stats::Histogram outstandingWritesHist;
statistics::Histogram outstandingWritesHist;
unsigned int outstandingWriteReqs;
/** Disable flag for transaction histograms. */
bool disableTransactionHists;
/** Histogram of number of read transactions per time bin */
Stats::Histogram readTransHist;
statistics::Histogram readTransHist;
unsigned int readTrans;
/** Histogram of number of timing write transactions per time bin */
Stats::Histogram writeTransHist;
statistics::Histogram writeTransHist;
unsigned int writeTrans;
/** Disable flag for address distributions. */
@@ -367,20 +367,21 @@ class CommMonitor : public SimObject
* Histogram of number of read accesses to addresses over
* time.
*/
Stats::SparseHistogram readAddrDist;
statistics::SparseHistogram readAddrDist;
/**
* Histogram of number of write accesses to addresses over
* time.
*/
Stats::SparseHistogram writeAddrDist;
statistics::SparseHistogram writeAddrDist;
/**
* Create the monitor stats and initialise all the members
* that are not statistics themselves, but used to control the
* stats or track values during a sample period.
*/
MonitorStats(Stats::Group *parent, const CommMonitorParams &params);
MonitorStats(statistics::Group *parent,
const CommMonitorParams &params);
void updateReqStats(const probing::PacketInfo& pkt, bool is_atomic,
bool expects_response);

91
src/mem/mem_ctrl.cc
View File

@@ -1182,106 +1182,105 @@ MemCtrl::burstAlign(Addr addr, bool is_dram) const
}
MemCtrl::CtrlStats::CtrlStats(MemCtrl &_ctrl)
: Stats::Group(&_ctrl),
: statistics::Group(&_ctrl),
ctrl(_ctrl),
ADD_STAT(readReqs, Stats::units::Count::get(),
ADD_STAT(readReqs, statistics::units::Count::get(),
"Number of read requests accepted"),
ADD_STAT(writeReqs, Stats::units::Count::get(),
ADD_STAT(writeReqs, statistics::units::Count::get(),
"Number of write requests accepted"),
ADD_STAT(readBursts, Stats::units::Count::get(),
ADD_STAT(readBursts, statistics::units::Count::get(),
"Number of controller read bursts, including those serviced by "
"the write queue"),
ADD_STAT(writeBursts, Stats::units::Count::get(),
ADD_STAT(writeBursts, statistics::units::Count::get(),
"Number of controller write bursts, including those merged in "
"the write queue"),
ADD_STAT(servicedByWrQ, Stats::units::Count::get(),
ADD_STAT(servicedByWrQ, statistics::units::Count::get(),
"Number of controller read bursts serviced by the write queue"),
ADD_STAT(mergedWrBursts, Stats::units::Count::get(),
ADD_STAT(mergedWrBursts, statistics::units::Count::get(),
"Number of controller write bursts merged with an existing one"),
ADD_STAT(neitherReadNorWriteReqs, Stats::units::Count::get(),
ADD_STAT(neitherReadNorWriteReqs, statistics::units::Count::get(),
"Number of requests that are neither read nor write"),
ADD_STAT(avgRdQLen, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(avgRdQLen, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average read queue length when enqueuing"),
ADD_STAT(avgWrQLen, Stats::units::Rate<
Stats::units::Count, Stats::units::Tick>::get(),
ADD_STAT(avgWrQLen, statistics::units::Rate<
statistics::units::Count, statistics::units::Tick>::get(),
"Average write queue length when enqueuing"),
ADD_STAT(numRdRetry, Stats::units::Count::get(),
ADD_STAT(numRdRetry, statistics::units::Count::get(),
"Number of times read queue was full causing retry"),
ADD_STAT(numWrRetry, Stats::units::Count::get(),
ADD_STAT(numWrRetry, statistics::units::Count::get(),
"Number of times write queue was full causing retry"),
ADD_STAT(readPktSize, Stats::units::Count::get(),
ADD_STAT(readPktSize, statistics::units::Count::get(),
"Read request sizes (log2)"),
ADD_STAT(writePktSize, Stats::units::Count::get(),
ADD_STAT(writePktSize, statistics::units::Count::get(),
"Write request sizes (log2)"),
ADD_STAT(rdQLenPdf, Stats::units::Count::get(),
ADD_STAT(rdQLenPdf, statistics::units::Count::get(),
"What read queue length does an incoming req see"),
ADD_STAT(wrQLenPdf, Stats::units::Count::get(),
ADD_STAT(wrQLenPdf, statistics::units::Count::get(),
"What write queue length does an incoming req see"),
ADD_STAT(rdPerTurnAround, Stats::units::Count::get(),
ADD_STAT(rdPerTurnAround, statistics::units::Count::get(),
"Reads before turning the bus around for writes"),
ADD_STAT(wrPerTurnAround, Stats::units::Count::get(),
ADD_STAT(wrPerTurnAround, statistics::units::Count::get(),
"Writes before turning the bus around for reads"),
ADD_STAT(bytesReadWrQ, Stats::units::Byte::get(),
ADD_STAT(bytesReadWrQ, statistics::units::Byte::get(),
"Total number of bytes read from write queue"),
ADD_STAT(bytesReadSys, Stats::units::Byte::get(),
ADD_STAT(bytesReadSys, statistics::units::Byte::get(),
"Total read bytes from the system interface side"),
ADD_STAT(bytesWrittenSys, Stats::units::Byte::get(),
ADD_STAT(bytesWrittenSys, statistics::units::Byte::get(),
"Total written bytes from the system interface side"),
ADD_STAT(avgRdBWSys, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgRdBWSys, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average system read bandwidth in Byte/s"),
ADD_STAT(avgWrBWSys, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgWrBWSys, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average system write bandwidth in Byte/s"),
ADD_STAT(totGap, Stats::units::Tick::get(), "Total gap between requests"),
ADD_STAT(avgGap, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(totGap, statistics::units::Tick::get(), "Total gap between requests"),
ADD_STAT(avgGap, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average gap between requests"),
ADD_STAT(requestorReadBytes, Stats::units::Byte::get(),
ADD_STAT(requestorReadBytes, statistics::units::Byte::get(),
"Per-requestor bytes read from memory"),
ADD_STAT(requestorWriteBytes, Stats::units::Byte::get(),
ADD_STAT(requestorWriteBytes, statistics::units::Byte::get(),
"Per-requestor bytes write to memory"),
ADD_STAT(requestorReadRate, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(requestorReadRate, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Per-requestor bytes read from memory rate"),
ADD_STAT(requestorWriteRate, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(requestorWriteRate, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Per-requestor bytes write to memory rate"),
ADD_STAT(requestorReadAccesses, Stats::units::Count::get(),
ADD_STAT(requestorReadAccesses, statistics::units::Count::get(),
"Per-requestor read serviced memory accesses"),
ADD_STAT(requestorWriteAccesses, Stats::units::Count::get(),
ADD_STAT(requestorWriteAccesses, statistics::units::Count::get(),
"Per-requestor write serviced memory accesses"),
ADD_STAT(requestorReadTotalLat, Stats::units::Tick::get(),
ADD_STAT(requestorReadTotalLat, statistics::units::Tick::get(),
"Per-requestor read total memory access latency"),
ADD_STAT(requestorWriteTotalLat, Stats::units::Tick::get(),
ADD_STAT(requestorWriteTotalLat, statistics::units::Tick::get(),
"Per-requestor write total memory access latency"),
ADD_STAT(requestorReadAvgLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(requestorReadAvgLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Per-requestor read average memory access latency"),
ADD_STAT(requestorWriteAvgLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(requestorWriteAvgLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Per-requestor write average memory access latency")
{
}
void
MemCtrl::CtrlStats::regStats()
{
using namespace Stats;
using namespace statistics;
assert(ctrl.system());
const auto max_requestors = ctrl.system()->maxRequestors();

70
src/mem/mem_ctrl.hh
View File

@@ -525,7 +525,7 @@ class MemCtrl : public qos::MemCtrl
*/
Tick nextReqTime;
struct CtrlStats : public Stats::Group
struct CtrlStats : public statistics::Group
{
CtrlStats(MemCtrl &ctrl);
@@ -534,55 +534,55 @@ class MemCtrl : public qos::MemCtrl
MemCtrl &ctrl;
// All statistics that the model needs to capture
Stats::Scalar readReqs;
Stats::Scalar writeReqs;
Stats::Scalar readBursts;
Stats::Scalar writeBursts;
Stats::Scalar servicedByWrQ;
Stats::Scalar mergedWrBursts;
Stats::Scalar neitherReadNorWriteReqs;
statistics::Scalar readReqs;
statistics::Scalar writeReqs;
statistics::Scalar readBursts;
statistics::Scalar writeBursts;
statistics::Scalar servicedByWrQ;
statistics::Scalar mergedWrBursts;
statistics::Scalar neitherReadNorWriteReqs;
// Average queue lengths
Stats::Average avgRdQLen;
Stats::Average avgWrQLen;
statistics::Average avgRdQLen;
statistics::Average avgWrQLen;
Stats::Scalar numRdRetry;
Stats::Scalar numWrRetry;
Stats::Vector readPktSize;
Stats::Vector writePktSize;
Stats::Vector rdQLenPdf;
Stats::Vector wrQLenPdf;
Stats::Histogram rdPerTurnAround;
Stats::Histogram wrPerTurnAround;
statistics::Scalar numRdRetry;
statistics::Scalar numWrRetry;
statistics::Vector readPktSize;
statistics::Vector writePktSize;
statistics::Vector rdQLenPdf;
statistics::Vector wrQLenPdf;
statistics::Histogram rdPerTurnAround;
statistics::Histogram wrPerTurnAround;
Stats::Scalar bytesReadWrQ;
Stats::Scalar bytesReadSys;
Stats::Scalar bytesWrittenSys;
statistics::Scalar bytesReadWrQ;
statistics::Scalar bytesReadSys;
statistics::Scalar bytesWrittenSys;
// Average bandwidth
Stats::Formula avgRdBWSys;
Stats::Formula avgWrBWSys;
statistics::Formula avgRdBWSys;
statistics::Formula avgWrBWSys;
Stats::Scalar totGap;
Stats::Formula avgGap;
statistics::Scalar totGap;
statistics::Formula avgGap;
// per-requestor bytes read and written to memory
Stats::Vector requestorReadBytes;
Stats::Vector requestorWriteBytes;
statistics::Vector requestorReadBytes;
statistics::Vector requestorWriteBytes;
// per-requestor bytes read and written to memory rate
Stats::Formula requestorReadRate;
Stats::Formula requestorWriteRate;
statistics::Formula requestorReadRate;
statistics::Formula requestorWriteRate;
// per-requestor read and write serviced memory accesses
Stats::Vector requestorReadAccesses;
Stats::Vector requestorWriteAccesses;
statistics::Vector requestorReadAccesses;
statistics::Vector requestorWriteAccesses;
// per-requestor read and write total memory access latency
Stats::Vector requestorReadTotalLat;
Stats::Vector requestorWriteTotalLat;
statistics::Vector requestorReadTotalLat;
statistics::Vector requestorWriteTotalLat;
// per-requestor raed and write average memory access latency
Stats::Formula requestorReadAvgLat;
Stats::Formula requestorWriteAvgLat;
statistics::Formula requestorReadAvgLat;
statistics::Formula requestorWriteAvgLat;
};
CtrlStats stats;

158
src/mem/mem_interface.cc
View File

@@ -1846,69 +1846,69 @@ DRAMInterface::DRAMStats::resetStats()
}
DRAMInterface::DRAMStats::DRAMStats(DRAMInterface &_dram)
: Stats::Group(&_dram),
: statistics::Group(&_dram),
dram(_dram),
ADD_STAT(readBursts, Stats::units::Count::get(),
ADD_STAT(readBursts, statistics::units::Count::get(),
"Number of DRAM read bursts"),
ADD_STAT(writeBursts, Stats::units::Count::get(),
ADD_STAT(writeBursts, statistics::units::Count::get(),
"Number of DRAM write bursts"),
ADD_STAT(perBankRdBursts, Stats::units::Count::get(),
ADD_STAT(perBankRdBursts, statistics::units::Count::get(),
"Per bank write bursts"),
ADD_STAT(perBankWrBursts, Stats::units::Count::get(),
ADD_STAT(perBankWrBursts, statistics::units::Count::get(),
"Per bank write bursts"),
ADD_STAT(totQLat, Stats::units::Tick::get(), "Total ticks spent queuing"),
ADD_STAT(totBusLat, Stats::units::Tick::get(),
ADD_STAT(totQLat, statistics::units::Tick::get(), "Total ticks spent queuing"),
ADD_STAT(totBusLat, statistics::units::Tick::get(),
"Total ticks spent in databus transfers"),
ADD_STAT(totMemAccLat, Stats::units::Tick::get(),
ADD_STAT(totMemAccLat, statistics::units::Tick::get(),
"Total ticks spent from burst creation until serviced "
"by the DRAM"),
ADD_STAT(avgQLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgQLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average queueing delay per DRAM burst"),
ADD_STAT(avgBusLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgBusLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average bus latency per DRAM burst"),
ADD_STAT(avgMemAccLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgMemAccLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average memory access latency per DRAM burst"),
ADD_STAT(readRowHits, Stats::units::Count::get(),
ADD_STAT(readRowHits, statistics::units::Count::get(),
"Number of row buffer hits during reads"),
ADD_STAT(writeRowHits, Stats::units::Count::get(),
ADD_STAT(writeRowHits, statistics::units::Count::get(),
"Number of row buffer hits during writes"),
ADD_STAT(readRowHitRate, Stats::units::Ratio::get(),
ADD_STAT(readRowHitRate, statistics::units::Ratio::get(),
"Row buffer hit rate for reads"),
ADD_STAT(writeRowHitRate, Stats::units::Ratio::get(),
ADD_STAT(writeRowHitRate, statistics::units::Ratio::get(),
"Row buffer hit rate for writes"),
ADD_STAT(bytesPerActivate, Stats::units::Byte::get(),
ADD_STAT(bytesPerActivate, statistics::units::Byte::get(),
"Bytes accessed per row activation"),
ADD_STAT(bytesRead, Stats::units::Byte::get(),
ADD_STAT(bytesRead, statistics::units::Byte::get(),
"Total number of bytes read from DRAM"),
ADD_STAT(bytesWritten, Stats::units::Byte::get(),
ADD_STAT(bytesWritten, statistics::units::Byte::get(),
"Total number of bytes written to DRAM"),
ADD_STAT(avgRdBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgRdBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average DRAM read bandwidth in MiBytes/s"),
ADD_STAT(avgWrBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgWrBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average DRAM write bandwidth in MiBytes/s"),
ADD_STAT(peakBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(peakBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Theoretical peak bandwidth in MiByte/s"),
ADD_STAT(busUtil, Stats::units::Ratio::get(),
ADD_STAT(busUtil, statistics::units::Ratio::get(),
"Data bus utilization in percentage"),
ADD_STAT(busUtilRead, Stats::units::Ratio::get(),
ADD_STAT(busUtilRead, statistics::units::Ratio::get(),
"Data bus utilization in percentage for reads"),
ADD_STAT(busUtilWrite, Stats::units::Ratio::get(),
ADD_STAT(busUtilWrite, statistics::units::Ratio::get(),
"Data bus utilization in percentage for writes"),
ADD_STAT(pageHitRate, Stats::units::Ratio::get(),
ADD_STAT(pageHitRate, statistics::units::Ratio::get(),
"Row buffer hit rate, read and write combined")
{
@@ -1917,7 +1917,7 @@ DRAMInterface::DRAMStats::DRAMStats(DRAMInterface &_dram)
void
DRAMInterface::DRAMStats::regStats()
{
using namespace Stats;
using namespace statistics;
avgQLat.precision(2);
avgBusLat.precision(2);
@@ -1963,38 +1963,38 @@ DRAMInterface::DRAMStats::regStats()
}
DRAMInterface::RankStats::RankStats(DRAMInterface &_dram, Rank &_rank)
: Stats::Group(&_dram, csprintf("rank%d", _rank.rank).c_str()),
: statistics::Group(&_dram, csprintf("rank%d", _rank.rank).c_str()),
rank(_rank),
ADD_STAT(actEnergy, Stats::units::Joule::get(),
ADD_STAT(actEnergy, statistics::units::Joule::get(),
"Energy for activate commands per rank (pJ)"),
ADD_STAT(preEnergy, Stats::units::Joule::get(),
ADD_STAT(preEnergy, statistics::units::Joule::get(),
"Energy for precharge commands per rank (pJ)"),
ADD_STAT(readEnergy, Stats::units::Joule::get(),
ADD_STAT(readEnergy, statistics::units::Joule::get(),
"Energy for read commands per rank (pJ)"),
ADD_STAT(writeEnergy, Stats::units::Joule::get(),
ADD_STAT(writeEnergy, statistics::units::Joule::get(),
"Energy for write commands per rank (pJ)"),
ADD_STAT(refreshEnergy, Stats::units::Joule::get(),
ADD_STAT(refreshEnergy, statistics::units::Joule::get(),
"Energy for refresh commands per rank (pJ)"),
ADD_STAT(actBackEnergy, Stats::units::Joule::get(),
ADD_STAT(actBackEnergy, statistics::units::Joule::get(),
"Energy for active background per rank (pJ)"),
ADD_STAT(preBackEnergy, Stats::units::Joule::get(),
ADD_STAT(preBackEnergy, statistics::units::Joule::get(),
"Energy for precharge background per rank (pJ)"),
ADD_STAT(actPowerDownEnergy, Stats::units::Joule::get(),
ADD_STAT(actPowerDownEnergy, statistics::units::Joule::get(),
"Energy for active power-down per rank (pJ)"),
ADD_STAT(prePowerDownEnergy, Stats::units::Joule::get(),
ADD_STAT(prePowerDownEnergy, statistics::units::Joule::get(),
"Energy for precharge power-down per rank (pJ)"),
ADD_STAT(selfRefreshEnergy, Stats::units::Joule::get(),
ADD_STAT(selfRefreshEnergy, statistics::units::Joule::get(),
"Energy for self refresh per rank (pJ)"),
ADD_STAT(totalEnergy, Stats::units::Joule::get(),
ADD_STAT(totalEnergy, statistics::units::Joule::get(),
"Total energy per rank (pJ)"),
ADD_STAT(averagePower, Stats::units::Watt::get(),
ADD_STAT(averagePower, statistics::units::Watt::get(),
"Core power per rank (mW)"),
ADD_STAT(totalIdleTime, Stats::units::Tick::get(),
ADD_STAT(totalIdleTime, statistics::units::Tick::get(),
"Total Idle time Per DRAM Rank"),
ADD_STAT(pwrStateTime, Stats::units::Tick::get(),
ADD_STAT(pwrStateTime, statistics::units::Tick::get(),
"Time in different power states")
{
}
@@ -2002,7 +2002,7 @@ DRAMInterface::RankStats::RankStats(DRAMInterface &_dram, Rank &_rank)
void
DRAMInterface::RankStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
pwrStateTime
.init(6)
@@ -2017,7 +2017,7 @@ DRAMInterface::RankStats::regStats()
void
DRAMInterface::RankStats::resetStats()
{
Stats::Group::resetStats();
statistics::Group::resetStats();
rank.resetStats();
}
@@ -2025,7 +2025,7 @@ DRAMInterface::RankStats::resetStats()
void
DRAMInterface::RankStats::preDumpStats()
{
Stats::Group::preDumpStats();
statistics::Group::preDumpStats();
rank.computeStats();
}
@@ -2513,60 +2513,60 @@ NVMInterface::isBusy(bool read_queue_empty, bool all_writes_nvm)
NVMInterface::NVMStats::NVMStats(NVMInterface &_nvm)
: Stats::Group(&_nvm),
: statistics::Group(&_nvm),
nvm(_nvm),
ADD_STAT(readBursts, Stats::units::Count::get(),
ADD_STAT(readBursts, statistics::units::Count::get(),
"Number of NVM read bursts"),
ADD_STAT(writeBursts, Stats::units::Count::get(),
ADD_STAT(writeBursts, statistics::units::Count::get(),
"Number of NVM write bursts"),
ADD_STAT(perBankRdBursts, Stats::units::Count::get(),
ADD_STAT(perBankRdBursts, statistics::units::Count::get(),
"Per bank write bursts"),
ADD_STAT(perBankWrBursts, Stats::units::Count::get(),
ADD_STAT(perBankWrBursts, statistics::units::Count::get(),
"Per bank write bursts"),
ADD_STAT(totQLat, Stats::units::Tick::get(), "Total ticks spent queuing"),
ADD_STAT(totBusLat, Stats::units::Tick::get(),
ADD_STAT(totQLat, statistics::units::Tick::get(), "Total ticks spent queuing"),
ADD_STAT(totBusLat, statistics::units::Tick::get(),
"Total ticks spent in databus transfers"),
ADD_STAT(totMemAccLat, Stats::units::Tick::get(),
ADD_STAT(totMemAccLat, statistics::units::Tick::get(),
"Total ticks spent from burst creation until serviced "
"by the NVM"),
ADD_STAT(avgQLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgQLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average queueing delay per NVM burst"),
ADD_STAT(avgBusLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgBusLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average bus latency per NVM burst"),
ADD_STAT(avgMemAccLat, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
ADD_STAT(avgMemAccLat, statistics::units::Rate<
statistics::units::Tick, statistics::units::Count>::get(),
"Average memory access latency per NVM burst"),
ADD_STAT(bytesRead, Stats::units::Byte::get(),
ADD_STAT(bytesRead, statistics::units::Byte::get(),
"Total number of bytes read from DRAM"),
ADD_STAT(bytesWritten, Stats::units::Byte::get(),
ADD_STAT(bytesWritten, statistics::units::Byte::get(),
"Total number of bytes written to DRAM"),
ADD_STAT(avgRdBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgRdBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average DRAM read bandwidth in MiBytes/s"),
ADD_STAT(avgWrBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(avgWrBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Average DRAM write bandwidth in MiBytes/s"),
ADD_STAT(peakBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
ADD_STAT(peakBW, statistics::units::Rate<
statistics::units::Byte, statistics::units::Second>::get(),
"Theoretical peak bandwidth in MiByte/s"),
ADD_STAT(busUtil, Stats::units::Ratio::get(),
ADD_STAT(busUtil, statistics::units::Ratio::get(),
"NVM Data bus utilization in percentage"),
ADD_STAT(busUtilRead, Stats::units::Ratio::get(),
ADD_STAT(busUtilRead, statistics::units::Ratio::get(),
"NVM Data bus read utilization in percentage"),
ADD_STAT(busUtilWrite, Stats::units::Ratio::get(),
ADD_STAT(busUtilWrite, statistics::units::Ratio::get(),
"NVM Data bus write utilization in percentage"),
ADD_STAT(pendingReads, Stats::units::Count::get(),
ADD_STAT(pendingReads, statistics::units::Count::get(),
"Reads issued to NVM for which data has not been transferred"),
ADD_STAT(pendingWrites, Stats::units::Count::get(),
ADD_STAT(pendingWrites, statistics::units::Count::get(),
"Number of outstanding writes to NVM"),
ADD_STAT(bytesPerBank, Stats::units::Byte::get(),
ADD_STAT(bytesPerBank, statistics::units::Byte::get(),
"Bytes read within a bank before loading new bank")
{
@@ -2575,7 +2575,7 @@ NVMInterface::NVMStats::NVMStats(NVMInterface &_nvm)
void
NVMInterface::NVMStats::regStats()
{
using namespace Stats;
using namespace statistics;
perBankRdBursts.init(nvm.ranksPerChannel == 0 ? 1 :
nvm.banksPerRank * nvm.ranksPerChannel);

124
src/mem/mem_interface.hh
View File

@@ -397,7 +397,7 @@ class DRAMInterface : public MemInterface
};
class Rank;
struct RankStats : public Stats::Group
struct RankStats : public statistics::Group
{
RankStats(DRAMInterface &dram, Rank &rank);
@@ -410,50 +410,50 @@ class DRAMInterface : public MemInterface
/*
* Command energies
*/
Stats::Scalar actEnergy;
Stats::Scalar preEnergy;
Stats::Scalar readEnergy;
Stats::Scalar writeEnergy;
Stats::Scalar refreshEnergy;
statistics::Scalar actEnergy;
statistics::Scalar preEnergy;
statistics::Scalar readEnergy;
statistics::Scalar writeEnergy;
statistics::Scalar refreshEnergy;
/*
* Active Background Energy
*/
Stats::Scalar actBackEnergy;
statistics::Scalar actBackEnergy;
/*
* Precharge Background Energy
*/
Stats::Scalar preBackEnergy;
statistics::Scalar preBackEnergy;
/*
* Active Power-Down Energy
*/
Stats::Scalar actPowerDownEnergy;
statistics::Scalar actPowerDownEnergy;
/*
* Precharge Power-Down Energy
*/
Stats::Scalar prePowerDownEnergy;
statistics::Scalar prePowerDownEnergy;
/*
* self Refresh Energy
*/
Stats::Scalar selfRefreshEnergy;
statistics::Scalar selfRefreshEnergy;
Stats::Scalar totalEnergy;
Stats::Scalar averagePower;
statistics::Scalar totalEnergy;
statistics::Scalar averagePower;
/**
* Stat to track total DRAM idle time
*
*/
Stats::Scalar totalIdleTime;
statistics::Scalar totalIdleTime;
/**
* Track time spent in each power state.
*/
Stats::Vector pwrStateTime;
statistics::Vector pwrStateTime;
};
/**
@@ -800,7 +800,7 @@ class DRAMInterface : public MemInterface
Tick pre_tick, bool auto_or_preall = false,
bool trace = true);
struct DRAMStats : public Stats::Group
struct DRAMStats : public statistics::Group
{
DRAMStats(DRAMInterface &dram);
@@ -810,42 +810,42 @@ class DRAMInterface : public MemInterface
DRAMInterface &dram;
/** total number of DRAM bursts serviced */
Stats::Scalar readBursts;
Stats::Scalar writeBursts;
statistics::Scalar readBursts;
statistics::Scalar writeBursts;
/** DRAM per bank stats */
Stats::Vector perBankRdBursts;
Stats::Vector perBankWrBursts;
statistics::Vector perBankRdBursts;
statistics::Vector perBankWrBursts;
// Latencies summed over all requests
Stats::Scalar totQLat;
Stats::Scalar totBusLat;
Stats::Scalar totMemAccLat;
statistics::Scalar totQLat;
statistics::Scalar totBusLat;
statistics::Scalar totMemAccLat;
// Average latencies per request
Stats::Formula avgQLat;
Stats::Formula avgBusLat;
Stats::Formula avgMemAccLat;
statistics::Formula avgQLat;
statistics::Formula avgBusLat;
statistics::Formula avgMemAccLat;
// Row hit count and rate
Stats::Scalar readRowHits;
Stats::Scalar writeRowHits;
Stats::Formula readRowHitRate;
Stats::Formula writeRowHitRate;
Stats::Histogram bytesPerActivate;
statistics::Scalar readRowHits;
statistics::Scalar writeRowHits;
statistics::Formula readRowHitRate;
statistics::Formula writeRowHitRate;
statistics::Histogram bytesPerActivate;
// Number of bytes transferred to/from DRAM
Stats::Scalar bytesRead;
Stats::Scalar bytesWritten;
statistics::Scalar bytesRead;
statistics::Scalar bytesWritten;
// Average bandwidth
Stats::Formula avgRdBW;
Stats::Formula avgWrBW;
Stats::Formula peakBW;
statistics::Formula avgRdBW;
statistics::Formula avgWrBW;
statistics::Formula peakBW;
// bus utilization
Stats::Formula busUtil;
Stats::Formula busUtilRead;
Stats::Formula busUtilWrite;
Stats::Formula pageHitRate;
statistics::Formula busUtil;
statistics::Formula busUtilRead;
statistics::Formula busUtilWrite;
statistics::Formula pageHitRate;
};
DRAMStats stats;
@@ -1058,7 +1058,7 @@ class NVMInterface : public MemInterface
const Tick tWRITE;
const Tick tSEND;
struct NVMStats : public Stats::Group
struct NVMStats : public statistics::Group
{
NVMStats(NVMInterface &nvm);
@@ -1067,37 +1067,37 @@ class NVMInterface : public MemInterface
NVMInterface &nvm;
/** NVM stats */
Stats::Scalar readBursts;
Stats::Scalar writeBursts;
statistics::Scalar readBursts;
statistics::Scalar writeBursts;
Stats::Vector perBankRdBursts;
Stats::Vector perBankWrBursts;
statistics::Vector perBankRdBursts;
statistics::Vector perBankWrBursts;
// Latencies summed over all requests
Stats::Scalar totQLat;
Stats::Scalar totBusLat;
Stats::Scalar totMemAccLat;
statistics::Scalar totQLat;
statistics::Scalar totBusLat;
statistics::Scalar totMemAccLat;
// Average latencies per request
Stats::Formula avgQLat;
Stats::Formula avgBusLat;
Stats::Formula avgMemAccLat;
statistics::Formula avgQLat;
statistics::Formula avgBusLat;
statistics::Formula avgMemAccLat;
Stats::Scalar bytesRead;
Stats::Scalar bytesWritten;
statistics::Scalar bytesRead;
statistics::Scalar bytesWritten;
// Average bandwidth
Stats::Formula avgRdBW;
Stats::Formula avgWrBW;
Stats::Formula peakBW;
Stats::Formula busUtil;
Stats::Formula busUtilRead;
Stats::Formula busUtilWrite;
statistics::Formula avgRdBW;
statistics::Formula avgWrBW;
statistics::Formula peakBW;
statistics::Formula busUtil;
statistics::Formula busUtilRead;
statistics::Formula busUtilWrite;
/** NVM stats */
Stats::Histogram pendingReads;
Stats::Histogram pendingWrites;
Stats::Histogram bytesPerBank;
statistics::Histogram pendingReads;
statistics::Histogram pendingWrites;
statistics::Histogram bytesPerBank;
};
NVMStats stats;

16
src/mem/probes/mem_footprint.cc
View File

@@ -60,21 +60,21 @@ MemFootprintProbe::MemFootprintProbe(const MemFootprintProbeParams &p)
"MemFootprintProbe expects page size parameter is power of 2");
}
MemFootprintProbe::
MemFootprintProbeStats::MemFootprintProbeStats(MemFootprintProbe *parent)
: Stats::Group(parent),
ADD_STAT(cacheLine, Stats::units::Count::get(),
MemFootprintProbe::MemFootprintProbeStats::MemFootprintProbeStats(
MemFootprintProbe *parent)
: statistics::Group(parent),
ADD_STAT(cacheLine, statistics::units::Count::get(),
"Memory footprint at cache line granularity"),
ADD_STAT(cacheLineTotal, Stats::units::Count::get(),
ADD_STAT(cacheLineTotal, statistics::units::Count::get(),
"Total memory footprint at cache line granularity since "
"simulation begin"),
ADD_STAT(page, Stats::units::Count::get(),
ADD_STAT(page, statistics::units::Count::get(),
"Memory footprint at page granularity"),
ADD_STAT(pageTotal, Stats::units::Count::get(),
ADD_STAT(pageTotal, statistics::units::Count::get(),
"Total memory footprint at page granularity since simulation "
"begin")
{
using namespace Stats;
using namespace statistics;
// clang-format off
cacheLine.flags(nozero | nonan);
cacheLineTotal.flags(nozero | nonan);

10
src/mem/probes/mem_footprint.hh
View File

@@ -71,18 +71,18 @@ class MemFootprintProbe : public BaseMemProbe
void insertAddr(Addr addr, AddrSet *set, uint64_t limit);
void handleRequest(const probing::PacketInfo &pkt_info) override;
struct MemFootprintProbeStats : public Stats::Group
struct MemFootprintProbeStats : public statistics::Group
{
MemFootprintProbeStats(MemFootprintProbe *parent);
/// Footprint at cache line size granularity
Stats::Scalar cacheLine;
statistics::Scalar cacheLine;
/// Footprint at cache line size granularity, since simulation begin
Stats::Scalar cacheLineTotal;
statistics::Scalar cacheLineTotal;
/// Footprint at page granularity
Stats::Scalar page;
statistics::Scalar page;
/// Footprint at page granularity, since simulation begin
Stats::Scalar pageTotal;
statistics::Scalar pageTotal;
};
// Addr set to track unique cache lines accessed

18
src/mem/probes/stack_dist.cc
View File

@@ -53,21 +53,21 @@ StackDistProbe::StackDistProbe(const StackDistProbeParams &p)
"larger or equal to the system's cahce line size.");
}
StackDistProbe::
StackDistProbeStats::StackDistProbeStats(StackDistProbe *parent)
: Stats::Group(parent),
ADD_STAT(readLinearHist, Stats::units::Count::get(),
StackDistProbe::StackDistProbeStats::StackDistProbeStats(
StackDistProbe *parent)
: statistics::Group(parent),
ADD_STAT(readLinearHist, statistics::units::Count::get(),
"Reads linear distribution"),
ADD_STAT(readLogHist, Stats::units::Ratio::get(),
ADD_STAT(readLogHist, statistics::units::Ratio::get(),
"Reads logarithmic distribution"),
ADD_STAT(writeLinearHist, Stats::units::Count::get(),
ADD_STAT(writeLinearHist, statistics::units::Count::get(),
"Writes linear distribution"),
ADD_STAT(writeLogHist, Stats::units::Ratio::get(),
ADD_STAT(writeLogHist, statistics::units::Ratio::get(),
"Writes logarithmic distribution"),
ADD_STAT(infiniteSD, Stats::units::Count::get(),
ADD_STAT(infiniteSD, statistics::units::Count::get(),
"Number of requests with infinite stack distance")
{
using namespace Stats;
using namespace statistics;
const StackDistProbeParams &p =
dynamic_cast<const StackDistProbeParams &>(parent->params());

12
src/mem/probes/stack_dist.hh
View File

@@ -66,24 +66,24 @@ class StackDistProbe : public BaseMemProbe
protected:
StackDistCalc calc;
struct StackDistProbeStats : public Stats::Group
struct StackDistProbeStats : public statistics::Group
{
StackDistProbeStats(StackDistProbe* parent);
// Reads linear histogram
Stats::Histogram readLinearHist;
statistics::Histogram readLinearHist;
// Reads logarithmic histogram
Stats::SparseHistogram readLogHist;
statistics::SparseHistogram readLogHist;
// Writes linear histogram
Stats::Histogram writeLinearHist;
statistics::Histogram writeLinearHist;
// Writes logarithmic histogram
Stats::SparseHistogram writeLogHist;
statistics::SparseHistogram writeLogHist;
// Writes logarithmic histogram
Stats::Scalar infiniteSD;
statistics::Scalar infiniteSD;
} stats;
};

22
src/mem/qos/mem_ctrl.cc
View File

@@ -280,26 +280,26 @@ MemCtrl::addRequestor(RequestorID id)
}
MemCtrl::MemCtrlStats::MemCtrlStats(MemCtrl &mc)
: Stats::Group(&mc),
: statistics::Group(&mc),
memCtrl(mc),
ADD_STAT(avgPriority, Stats::units::Count::get(),
ADD_STAT(avgPriority, statistics::units::Count::get(),
"Average QoS priority value for accepted requests"),
ADD_STAT(avgPriorityDistance, Stats::units::Count::get(),
ADD_STAT(avgPriorityDistance, statistics::units::Count::get(),
"Average QoS priority distance between assigned and queued "
"values"),
ADD_STAT(priorityMinLatency, Stats::units::Second::get(),
ADD_STAT(priorityMinLatency, statistics::units::Second::get(),
"per QoS priority minimum request to response latency"),
ADD_STAT(priorityMaxLatency, Stats::units::Second::get(),
ADD_STAT(priorityMaxLatency, statistics::units::Second::get(),
"per QoS priority maximum request to response latency"),
ADD_STAT(numReadWriteTurnArounds, Stats::units::Count::get(),
ADD_STAT(numReadWriteTurnArounds, statistics::units::Count::get(),
"Number of turnarounds from READ to WRITE"),
ADD_STAT(numWriteReadTurnArounds, Stats::units::Count::get(),
ADD_STAT(numWriteReadTurnArounds, statistics::units::Count::get(),
"Number of turnarounds from WRITE to READ"),
ADD_STAT(numStayReadState, Stats::units::Count::get(),
ADD_STAT(numStayReadState, statistics::units::Count::get(),
"Number of times bus staying in READ state"),
ADD_STAT(numStayWriteState, Stats::units::Count::get(),
ADD_STAT(numStayWriteState, statistics::units::Count::get(),
"Number of times bus staying in WRITE state")
{
}
@@ -307,9 +307,9 @@ MemCtrl::MemCtrlStats::MemCtrlStats(MemCtrl &mc)
void
MemCtrl::MemCtrlStats::regStats()
{
Stats::Group::regStats();
statistics::Group::regStats();
using namespace Stats;
using namespace statistics;
System *system = memCtrl._system;
const auto max_requestors = system->maxRequestors();

18
src/mem/qos/mem_ctrl.hh
View File

@@ -136,7 +136,7 @@ class MemCtrl : public ClockedObject
/** bus state for next request event triggered */
BusState busStateNext;
struct MemCtrlStats : public Stats::Group
struct MemCtrlStats : public statistics::Group
{
MemCtrlStats(MemCtrl &mc);
@@ -145,25 +145,25 @@ class MemCtrl : public ClockedObject
const MemCtrl &memCtrl;
/** per-requestor average QoS priority */
Stats::VectorStandardDeviation avgPriority;
statistics::VectorStandardDeviation avgPriority;
/**
* per-requestor average QoS distance between assigned and
* queued values
*/
Stats::VectorStandardDeviation avgPriorityDistance;
statistics::VectorStandardDeviation avgPriorityDistance;
/** per-priority minimum latency */
Stats::Vector priorityMinLatency;
statistics::Vector priorityMinLatency;
/** per-priority maximum latency */
Stats::Vector priorityMaxLatency;
statistics::Vector priorityMaxLatency;
/** Count the number of turnarounds READ to WRITE */
Stats::Scalar numReadWriteTurnArounds;
statistics::Scalar numReadWriteTurnArounds;
/** Count the number of turnarounds WRITE to READ */
Stats::Scalar numWriteReadTurnArounds;
statistics::Scalar numWriteReadTurnArounds;
/** Count the number of times bus staying in READ state */
Stats::Scalar numStayReadState;
statistics::Scalar numStayReadState;
/** Count the number of times bus staying in WRITE state */
Stats::Scalar numStayWriteState;
statistics::Scalar numStayWriteState;
} stats;
/** Pointer to the System object */

8
src/mem/qos/mem_sink.cc
View File

@@ -336,11 +336,11 @@ MemSinkCtrl::drain()
}
}
MemSinkCtrl::MemSinkCtrlStats::MemSinkCtrlStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(numReadRetries, Stats::units::Count::get(),
MemSinkCtrl::MemSinkCtrlStats::MemSinkCtrlStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(numReadRetries, statistics::units::Count::get(),
"Number of read retries"),
ADD_STAT(numWriteRetries, Stats::units::Count::get(),
ADD_STAT(numWriteRetries, statistics::units::Count::get(),
"Number of write retries")
{
}

8
src/mem/qos/mem_sink.hh
View File

@@ -188,15 +188,15 @@ class MemSinkCtrl : public MemCtrl
/** Next request service time */
Tick nextRequest;
struct MemSinkCtrlStats : public Stats::Group
struct MemSinkCtrlStats : public statistics::Group
{
MemSinkCtrlStats(Stats::Group *parent);
MemSinkCtrlStats(statistics::Group *parent);
/** Count the number of read retries */
Stats::Scalar numReadRetries;
statistics::Scalar numReadRetries;
/** Count the number of write retries */
Stats::Scalar numWriteRetries;
statistics::Scalar numWriteRetries;
};
/**

10
src/mem/ruby/network/MessageBuffer.cc
View File

@@ -85,19 +85,19 @@ MessageBuffer::MessageBuffer(const Params &p)
// stats
m_not_avail_count
.flags(Stats::nozero);
.flags(statistics::nozero);
m_buf_msgs
.flags(Stats::nozero);
.flags(statistics::nozero);
m_stall_count
.flags(Stats::nozero);
.flags(statistics::nozero);
m_occupancy
.flags(Stats::nozero);
.flags(statistics::nozero);
m_stall_time
.flags(Stats::nozero);
.flags(statistics::nozero);
if (m_max_size > 0) {
m_occupancy = m_buf_msgs / m_max_size;

12
src/mem/ruby/network/MessageBuffer.hh
View File

@@ -256,12 +256,12 @@ class MessageBuffer : public SimObject
int m_input_link_id;
int m_vnet_id;
Stats::Scalar m_not_avail_count; // count the # of times I didn't have N
// slots available
Stats::Average m_buf_msgs;
Stats::Average m_stall_time;
Stats::Scalar m_stall_count;
Stats::Formula m_occupancy;
// Count the # of times I didn't have N slots available
statistics::Scalar m_not_avail_count;
statistics::Average m_buf_msgs;
statistics::Average m_stall_time;
statistics::Scalar m_stall_count;
statistics::Formula m_occupancy;
};
Tick random_time();

2
src/mem/ruby/network/Network.cc
View File

@@ -130,7 +130,7 @@ Network::Network(const Params &p)
}
// Register a callback function for combining the statistics
Stats::registerDumpCallback([this]() { collateStats(); });
statistics::registerDumpCallback([this]() { collateStats(); });
for (auto &it : dynamic_cast<Network *>(this)->params().ext_links) {
it->params().ext_node->initNetQueues();

41
src/mem/ruby/network/garnet/GarnetNetwork.cc
View File

@@ -369,25 +369,27 @@ GarnetNetwork::regStats()
m_packets_received
.init(m_virtual_networks)
.name(name() + ".packets_received")
.flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
.flags(statistics::pdf | statistics::total | statistics::nozero |
statistics::oneline)
;
m_packets_injected
.init(m_virtual_networks)
.name(name() + ".packets_injected")
.flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
.flags(statistics::pdf | statistics::total | statistics::nozero |
statistics::oneline)
;
m_packet_network_latency
.init(m_virtual_networks)
.name(name() + ".packet_network_latency")
.flags(Stats::oneline)
.flags(statistics::oneline)
;
m_packet_queueing_latency
.init(m_virtual_networks)
.name(name() + ".packet_queueing_latency")
.flags(Stats::oneline)
.flags(statistics::oneline)
;
for (int i = 0; i < m_virtual_networks; i++) {
@@ -399,13 +401,13 @@ GarnetNetwork::regStats()
m_avg_packet_vnet_latency
.name(name() + ".average_packet_vnet_latency")
.flags(Stats::oneline);
.flags(statistics::oneline);
m_avg_packet_vnet_latency =
m_packet_network_latency / m_packets_received;
m_avg_packet_vqueue_latency
.name(name() + ".average_packet_vqueue_latency")
.flags(Stats::oneline);
.flags(statistics::oneline);
m_avg_packet_vqueue_latency =
m_packet_queueing_latency / m_packets_received;
@@ -428,25 +430,27 @@ GarnetNetwork::regStats()
m_flits_received
.init(m_virtual_networks)
.name(name() + ".flits_received")
.flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
.flags(statistics::pdf | statistics::total | statistics::nozero |
statistics::oneline)
;
m_flits_injected
.init(m_virtual_networks)
.name(name() + ".flits_injected")
.flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
.flags(statistics::pdf | statistics::total | statistics::nozero |
statistics::oneline)
;
m_flit_network_latency
.init(m_virtual_networks)
.name(name() + ".flit_network_latency")
.flags(Stats::oneline)
.flags(statistics::oneline)
;
m_flit_queueing_latency
.init(m_virtual_networks)
.name(name() + ".flit_queueing_latency")
.flags(Stats::oneline)
.flags(statistics::oneline)
;
for (int i = 0; i < m_virtual_networks; i++) {
@@ -458,12 +462,12 @@ GarnetNetwork::regStats()
m_avg_flit_vnet_latency
.name(name() + ".average_flit_vnet_latency")
.flags(Stats::oneline);
.flags(statistics::oneline);
m_avg_flit_vnet_latency = m_flit_network_latency / m_flits_received;
m_avg_flit_vqueue_latency
.name(name() + ".average_flit_vqueue_latency")
.flags(Stats::oneline);
.flags(statistics::oneline);
m_avg_flit_vqueue_latency =
m_flit_queueing_latency / m_flits_received;
@@ -499,17 +503,20 @@ GarnetNetwork::regStats()
m_average_vc_load
.init(m_virtual_networks * m_max_vcs_per_vnet)
.name(name() + ".avg_vc_load")
.flags(Stats::pdf | Stats::total | Stats::nozero | Stats::oneline)
.flags(statistics::pdf | statistics::total | statistics::nozero |
statistics::oneline)
;
// Traffic distribution
for (int source = 0; source < m_routers.size(); ++source) {
m_data_traffic_distribution.push_back(std::vector<Stats::Scalar *>());
m_ctrl_traffic_distribution.push_back(std::vector<Stats::Scalar *>());
m_data_traffic_distribution.push_back(
std::vector<statistics::Scalar *>());
m_ctrl_traffic_distribution.push_back(
std::vector<statistics::Scalar *>());
for (int dest = 0; dest < m_routers.size(); ++dest) {
Stats::Scalar *data_packets = new Stats::Scalar();
Stats::Scalar *ctrl_packets = new Stats::Scalar();
statistics::Scalar *data_packets = new statistics::Scalar();
statistics::Scalar *ctrl_packets = new statistics::Scalar();
data_packets->name(name() + ".data_traffic_distribution." + "n" +
std::to_string(source) + "." + "n" + std::to_string(dest));

54
src/mem/ruby/network/garnet/GarnetNetwork.hh
View File

@@ -156,39 +156,39 @@ class GarnetNetwork : public Network
bool m_enable_fault_model;
// Statistical variables
Stats::Vector m_packets_received;
Stats::Vector m_packets_injected;
Stats::Vector m_packet_network_latency;
Stats::Vector m_packet_queueing_latency;
statistics::Vector m_packets_received;
statistics::Vector m_packets_injected;
statistics::Vector m_packet_network_latency;
statistics::Vector m_packet_queueing_latency;
Stats::Formula m_avg_packet_vnet_latency;
Stats::Formula m_avg_packet_vqueue_latency;
Stats::Formula m_avg_packet_network_latency;
Stats::Formula m_avg_packet_queueing_latency;
Stats::Formula m_avg_packet_latency;
statistics::Formula m_avg_packet_vnet_latency;
statistics::Formula m_avg_packet_vqueue_latency;
statistics::Formula m_avg_packet_network_latency;
statistics::Formula m_avg_packet_queueing_latency;
statistics::Formula m_avg_packet_latency;
Stats::Vector m_flits_received;
Stats::Vector m_flits_injected;
Stats::Vector m_flit_network_latency;
Stats::Vector m_flit_queueing_latency;
statistics::Vector m_flits_received;
statistics::Vector m_flits_injected;
statistics::Vector m_flit_network_latency;
statistics::Vector m_flit_queueing_latency;
Stats::Formula m_avg_flit_vnet_latency;
Stats::Formula m_avg_flit_vqueue_latency;
Stats::Formula m_avg_flit_network_latency;
Stats::Formula m_avg_flit_queueing_latency;
Stats::Formula m_avg_flit_latency;
statistics::Formula m_avg_flit_vnet_latency;
statistics::Formula m_avg_flit_vqueue_latency;
statistics::Formula m_avg_flit_network_latency;
statistics::Formula m_avg_flit_queueing_latency;
statistics::Formula m_avg_flit_latency;
Stats::Scalar m_total_ext_in_link_utilization;
Stats::Scalar m_total_ext_out_link_utilization;
Stats::Scalar m_total_int_link_utilization;
Stats::Scalar m_average_link_utilization;
Stats::Vector m_average_vc_load;
statistics::Scalar m_total_ext_in_link_utilization;
statistics::Scalar m_total_ext_out_link_utilization;
statistics::Scalar m_total_int_link_utilization;
statistics::Scalar m_average_link_utilization;
statistics::Vector m_average_vc_load;
Stats::Scalar m_total_hops;
Stats::Formula m_avg_hops;
statistics::Scalar m_total_hops;
statistics::Formula m_avg_hops;
std::vector<std::vector<Stats::Scalar *>> m_data_traffic_distribution;
std::vector<std::vector<Stats::Scalar *>> m_ctrl_traffic_distribution;
std::vector<std::vector<statistics::Scalar *>> m_data_traffic_distribution;
std::vector<std::vector<statistics::Scalar *>> m_ctrl_traffic_distribution;
private:
GarnetNetwork(const GarnetNetwork& obj);

10
src/mem/ruby/network/garnet/Router.cc
View File

@@ -185,27 +185,27 @@ Router::regStats()
m_buffer_reads
.name(name() + ".buffer_reads")
.flags(Stats::nozero)
.flags(statistics::nozero)
;
m_buffer_writes
.name(name() + ".buffer_writes")
.flags(Stats::nozero)
.flags(statistics::nozero)
;
m_crossbar_activity
.name(name() + ".crossbar_activity")
.flags(Stats::nozero)
.flags(statistics::nozero)
;
m_sw_input_arbiter_activity
.name(name() + ".sw_input_arbiter_activity")
.flags(Stats::nozero)
.flags(statistics::nozero)
;
m_sw_output_arbiter_activity
.name(name() + ".sw_output_arbiter_activity")
.flags(Stats::nozero)
.flags(statistics::nozero)
;
}

10
src/mem/ruby/network/garnet/Router.hh
View File

@@ -145,13 +145,13 @@ class Router : public BasicRouter, public Consumer
std::vector<std::shared_ptr<OutputUnit>> m_output_unit;
// Statistical variables required for power computations
Stats::Scalar m_buffer_reads;
Stats::Scalar m_buffer_writes;
statistics::Scalar m_buffer_reads;
statistics::Scalar m_buffer_writes;
Stats::Scalar m_sw_input_arbiter_activity;
Stats::Scalar m_sw_output_arbiter_activity;
statistics::Scalar m_sw_input_arbiter_activity;
statistics::Scalar m_sw_output_arbiter_activity;
Stats::Scalar m_crossbar_activity;
statistics::Scalar m_crossbar_activity;
};
#endif // __MEM_RUBY_NETWORK_GARNET_0_ROUTER_HH__

14
src/mem/ruby/network/simple/SimpleNetwork.cc
View File

@@ -144,17 +144,17 @@ SimpleNetwork::regStats()
for (MessageSizeType type = MessageSizeType_FIRST;
type < MessageSizeType_NUM; ++type) {
networkStats.m_msg_counts[(unsigned int) type] =
new Stats::Formula(&networkStats,
new statistics::Formula(&networkStats,
csprintf("msg_count.%s", MessageSizeType_to_string(type)).c_str());
networkStats.m_msg_counts[(unsigned int) type]
->flags(Stats::nozero)
->flags(statistics::nozero)
;
networkStats.m_msg_bytes[(unsigned int) type] =
new Stats::Formula(&networkStats,
new statistics::Formula(&networkStats,
csprintf("msg_byte.%s", MessageSizeType_to_string(type)).c_str());
networkStats.m_msg_bytes[(unsigned int) type]
->flags(Stats::nozero)
->flags(statistics::nozero)
;
// Now state what the formula is.
@@ -165,7 +165,7 @@ SimpleNetwork::regStats()
*(networkStats.m_msg_bytes[(unsigned int) type]) =
*(networkStats.m_msg_counts[(unsigned int) type]) *
Stats::constant(Network::MessageSizeType_to_int(type));
statistics::constant(Network::MessageSizeType_to_int(type));
}
}
@@ -234,8 +234,8 @@ SimpleNetwork::functionalWrite(Packet *pkt)
}
SimpleNetwork::
NetworkStats::NetworkStats(Stats::Group *parent)
: Stats::Group(parent)
NetworkStats::NetworkStats(statistics::Group *parent)
: statistics::Group(parent)
{
}

8
src/mem/ruby/network/simple/SimpleNetwork.hh
View File

@@ -104,13 +104,13 @@ class SimpleNetwork : public Network
const bool m_adaptive_routing;
struct NetworkStats : public Stats::Group
struct NetworkStats : public statistics::Group
{
NetworkStats(Stats::Group *parent);
NetworkStats(statistics::Group *parent);
//Statistical variables
Stats::Formula* m_msg_counts[MessageSizeType_NUM];
Stats::Formula* m_msg_bytes[MessageSizeType_NUM];
statistics::Formula* m_msg_counts[MessageSizeType_NUM];
statistics::Formula* m_msg_bytes[MessageSizeType_NUM];
} networkStats;
};

16
src/mem/ruby/network/simple/Switch.cc
View File

@@ -114,29 +114,29 @@ Switch::regStats()
for (const auto& throttle : throttles) {
switchStats.m_avg_utilization += throttle.getUtilization();
}
switchStats.m_avg_utilization /= Stats::constant(throttles.size());
switchStats.m_avg_utilization /= statistics::constant(throttles.size());
for (unsigned int type = MessageSizeType_FIRST;
type < MessageSizeType_NUM; ++type) {
switchStats.m_msg_counts[type] = new Stats::Formula(&switchStats,
switchStats.m_msg_counts[type] = new statistics::Formula(&switchStats,
csprintf("msg_count.%s",
MessageSizeType_to_string(MessageSizeType(type))).c_str());
switchStats.m_msg_counts[type]
->flags(Stats::nozero)
->flags(statistics::nozero)
;
switchStats.m_msg_bytes[type] = new Stats::Formula(&switchStats,
switchStats.m_msg_bytes[type] = new statistics::Formula(&switchStats,
csprintf("msg_bytes.%s",
MessageSizeType_to_string(MessageSizeType(type))).c_str());
switchStats.m_msg_bytes[type]
->flags(Stats::nozero)
->flags(statistics::nozero)
;
for (const auto& throttle : throttles) {
*(switchStats.m_msg_counts[type]) += throttle.getMsgCount(type);
}
*(switchStats.m_msg_bytes[type]) =
*(switchStats.m_msg_counts[type]) * Stats::constant(
*(switchStats.m_msg_counts[type]) * statistics::constant(
Network::MessageSizeType_to_int(MessageSizeType(type)));
}
}
@@ -199,8 +199,8 @@ Switch::functionalWrite(Packet *pkt)
}
Switch::
SwitchStats::SwitchStats(Stats::Group *parent)
: Stats::Group(parent),
SwitchStats::SwitchStats(statistics::Group *parent)
: statistics::Group(parent),
m_avg_utilization(this, "percent_links_utilized")
{

12
src/mem/ruby/network/simple/Switch.hh
View File

@@ -84,7 +84,7 @@ class Switch : public BasicRouter
void resetStats();
void collateStats();
void regStats();
const Stats::Formula & getMsgCount(unsigned int type) const
const statistics::Formula & getMsgCount(unsigned int type) const
{ return *(switchStats.m_msg_counts[type]); }
void print(std::ostream& out) const;
@@ -108,14 +108,14 @@ class Switch : public BasicRouter
public:
struct SwitchStats : public Stats::Group
struct SwitchStats : public statistics::Group
{
SwitchStats(Stats::Group *parent);
SwitchStats(statistics::Group *parent);
// Statistical variables
Stats::Formula m_avg_utilization;
Stats::Formula* m_msg_counts[MessageSizeType_NUM];
Stats::Formula* m_msg_bytes[MessageSizeType_NUM];
statistics::Formula m_avg_utilization;
statistics::Formula* m_msg_counts[MessageSizeType_NUM];
statistics::Formula* m_msg_bytes[MessageSizeType_NUM];
} switchStats;
};

14
src/mem/ruby/network/simple/Throttle.cc
View File

@@ -206,22 +206,22 @@ Throttle::regStats()
for (MessageSizeType type = MessageSizeType_FIRST;
type < MessageSizeType_NUM; ++type) {
throttleStats.m_msg_counts[(unsigned int)type] =
new Stats::Vector(&throttleStats,
new statistics::Vector(&throttleStats,
csprintf("msg_count.%s", MessageSizeType_to_string(type)).c_str());
throttleStats.m_msg_counts[(unsigned int)type]
->init(Network::getNumberOfVirtualNetworks())
.flags(Stats::nozero)
.flags(statistics::nozero)
;
throttleStats.m_msg_bytes[(unsigned int) type] =
new Stats::Formula(&throttleStats,
new statistics::Formula(&throttleStats,
csprintf("msg_bytes.%s", MessageSizeType_to_string(type)).c_str());
throttleStats.m_msg_bytes[(unsigned int) type]
->flags(Stats::nozero)
->flags(statistics::nozero)
;
*(throttleStats.m_msg_bytes[(unsigned int) type]) =
*(throttleStats.m_msg_counts[type]) * Stats::constant(
*(throttleStats.m_msg_counts[type]) * statistics::constant(
Network::MessageSizeType_to_int(type));
}
}
@@ -264,8 +264,8 @@ network_message_to_size(Message *net_msg_ptr)
}
Throttle::
ThrottleStats::ThrottleStats(Stats::Group *parent, const NodeID &nodeID)
: Stats::Group(parent, csprintf("throttle%02i", nodeID).c_str()),
ThrottleStats::ThrottleStats(statistics::Group *parent, const NodeID &nodeID)
: statistics::Group(parent, csprintf("throttle%02i", nodeID).c_str()),
m_link_utilization(this, "link_utilization")
{

14
src/mem/ruby/network/simple/Throttle.hh
View File

@@ -65,9 +65,9 @@ class Throttle : public Consumer
void wakeup();
// The average utilization (a fraction) since last clearStats()
const Stats::Scalar & getUtilization() const
const statistics::Scalar & getUtilization() const
{ return throttleStats.m_link_utilization; }
const Stats::Vector & getMsgCount(unsigned int type) const
const statistics::Vector & getMsgCount(unsigned int type) const
{ return *(throttleStats.m_msg_counts[type]); }
int getLinkBandwidth() const
@@ -108,14 +108,14 @@ class Throttle : public Consumer
double m_link_utilization_proxy;
struct ThrottleStats : public Stats::Group
struct ThrottleStats : public statistics::Group
{
ThrottleStats(Stats::Group *parent, const NodeID &nodeID);
ThrottleStats(statistics::Group *parent, const NodeID &nodeID);
// Statistical variables
Stats::Scalar m_link_utilization;
Stats::Vector* m_msg_counts[MessageSizeType_NUM];
Stats::Formula* m_msg_bytes[MessageSizeType_NUM];
statistics::Scalar m_link_utilization;
statistics::Vector* m_msg_counts[MessageSizeType_NUM];
statistics::Formula* m_msg_bytes[MessageSizeType_NUM];
} throttleStats;
};

128
src/mem/ruby/profiler/Profiler.cc
View File

@@ -102,8 +102,8 @@ Profiler::~Profiler()
}
Profiler::
ProfilerStats::ProfilerStats(Stats::Group *parent, Profiler *profiler)
: Stats::Group(parent),
ProfilerStats::ProfilerStats(statistics::Group *parent, Profiler *profiler)
: statistics::Group(parent),
perRequestTypeStats(parent),
perMachineTypeStats(parent),
perRequestTypeMachineTypeStats(parent),
@@ -118,152 +118,155 @@ ProfilerStats::ProfilerStats(Stats::Group *parent, Profiler *profiler)
{
delayHistogram
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
for (int i = 0; i < profiler->m_num_vnets; i++) {
delayVCHistogram.push_back(new Stats::Histogram(this));
delayVCHistogram.push_back(new statistics::Histogram(this));
delayVCHistogram[i]
->init(10)
.name(csprintf("delayVCHist.vnet_%i", i))
.desc(csprintf("delay histogram for vnet_%i", i))
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
}
m_outstandReqHistSeqr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_outstandReqHistCoalsr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_latencyHistSeqr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_latencyHistCoalsr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_hitLatencyHistSeqr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missLatencyHistSeqr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missLatencyHistCoalsr
.init(10)
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
}
Profiler::ProfilerStats::
PerRequestTypeStats::PerRequestTypeStats(Stats::Group *parent)
: Stats::Group(parent, "RequestType")
PerRequestTypeStats::PerRequestTypeStats(statistics::Group *parent)
: statistics::Group(parent, "RequestType")
{
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_typeLatencyHistSeqr.push_back(new Stats::Histogram(this));
m_typeLatencyHistSeqr.push_back(new statistics::Histogram(this));
m_typeLatencyHistSeqr[i]
->init(10)
.name(csprintf("%s.latency_hist_seqr", RubyRequestType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_typeLatencyHistCoalsr.push_back(new Stats::Histogram(this));
m_typeLatencyHistCoalsr.push_back(new statistics::Histogram(this));
m_typeLatencyHistCoalsr[i]
->init(10)
.name(csprintf("%s.latency_hist_coalsr", RubyRequestType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_hitTypeLatencyHistSeqr.push_back(new Stats::Histogram(this));
m_hitTypeLatencyHistSeqr.push_back(new statistics::Histogram(this));
m_hitTypeLatencyHistSeqr[i]
->init(10)
.name(csprintf("%s.hit_latency_hist_seqr", RubyRequestType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missTypeLatencyHistSeqr.push_back(new Stats::Histogram(this));
m_missTypeLatencyHistSeqr.push_back(new statistics::Histogram(this));
m_missTypeLatencyHistSeqr[i]
->init(10)
.name(csprintf("%s.miss_latency_hist_seqr", RubyRequestType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missTypeLatencyHistCoalsr.push_back(new Stats::Histogram(this));
m_missTypeLatencyHistCoalsr.push_back(new statistics::Histogram(this));
m_missTypeLatencyHistCoalsr[i]
->init(10)
.name(csprintf("%s.miss_latency_hist_coalsr", RubyRequestType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
}
}
Profiler::ProfilerStats::
PerMachineTypeStats::PerMachineTypeStats(Stats::Group *parent)
: Stats::Group(parent, "MachineType")
PerMachineTypeStats::PerMachineTypeStats(statistics::Group *parent)
: statistics::Group(parent, "MachineType")
{
for (int i = 0; i < MachineType_NUM; i++) {
m_hitMachLatencyHistSeqr.push_back(new Stats::Histogram(this));
m_hitMachLatencyHistSeqr.push_back(new statistics::Histogram(this));
m_hitMachLatencyHistSeqr[i]
->init(10)
.name(csprintf("%s.hit_mach_latency_hist_seqr", MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missMachLatencyHistSeqr.push_back(new Stats::Histogram(this));
m_missMachLatencyHistSeqr.push_back(new statistics::Histogram(this));
m_missMachLatencyHistSeqr[i]
->init(10)
.name(csprintf("%s.miss_mach_latency_hist_seqr", MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_missMachLatencyHistCoalsr.push_back(new Stats::Histogram(this));
m_missMachLatencyHistCoalsr.push_back(new statistics::Histogram(this));
m_missMachLatencyHistCoalsr[i]
->init(10)
.name(csprintf("%s.miss_mach_latency_hist_coalsr",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_IssueToInitialDelayHistSeqr.push_back(new Stats::Histogram(this));
m_IssueToInitialDelayHistSeqr.push_back(
new statistics::Histogram(this));
m_IssueToInitialDelayHistSeqr[i]
->init(10)
.name(csprintf(
"%s.miss_latency_hist_seqr.issue_to_initial_request",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_IssueToInitialDelayHistCoalsr.push_back(new Stats::Histogram(this));
m_IssueToInitialDelayHistCoalsr.push_back(
new statistics::Histogram(this));
m_IssueToInitialDelayHistCoalsr[i]
->init(10)
.name(csprintf(
"%s.miss_latency_hist_coalsr.issue_to_initial_request",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_InitialToForwardDelayHistSeqr.push_back(new Stats::Histogram(this));
m_InitialToForwardDelayHistSeqr.push_back(
new statistics::Histogram(this));
m_InitialToForwardDelayHistSeqr[i]
->init(10)
.name(csprintf("%s.miss_latency_hist_seqr.initial_to_forward",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_InitialToForwardDelayHistCoalsr
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_InitialToForwardDelayHistCoalsr[i]
->init(10)
.name(csprintf("%s.miss_latency_hist_coalsr.initial_to_forward",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_ForwardToFirstResponseDelayHistSeqr
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_ForwardToFirstResponseDelayHistSeqr[i]
->init(10)
@@ -271,86 +274,89 @@ PerMachineTypeStats::PerMachineTypeStats(Stats::Group *parent)
"%s.miss_latency_hist_seqr.forward_to_first_response",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_ForwardToFirstResponseDelayHistCoalsr
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_ForwardToFirstResponseDelayHistCoalsr[i]
->init(10)
.name(csprintf(
"%s.miss_latency_hist_coalsr.forward_to_first_response",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_FirstResponseToCompletionDelayHistSeqr
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_FirstResponseToCompletionDelayHistSeqr[i]
->init(10)
.name(csprintf(
"%s.miss_latency_hist_seqr.first_response_to_completion",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_FirstResponseToCompletionDelayHistCoalsr
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_FirstResponseToCompletionDelayHistCoalsr[i]
->init(10)
.name(csprintf(
"%s.miss_latency_hist_coalsr.first_response_to_completion",
MachineType(i)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf | statistics::oneline);
m_IncompleteTimesSeqr.push_back(new Stats::Scalar(this));
m_IncompleteTimesSeqr.push_back(new statistics::Scalar(this));
m_IncompleteTimesSeqr[i]
->name(csprintf("%s.incomplete_times_seqr", MachineType(i)))
.desc("")
.flags(Stats::nozero);
.flags(statistics::nozero);
}
}
Profiler::ProfilerStats::
PerRequestTypeMachineTypeStats::
PerRequestTypeMachineTypeStats(Stats::Group *parent)
: Stats::Group(parent, "RequestTypeMachineType")
PerRequestTypeMachineTypeStats(statistics::Group *parent)
: statistics::Group(parent, "RequestTypeMachineType")
{
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_hitTypeMachLatencyHistSeqr
.push_back(std::vector<Stats::Histogram *>());
.push_back(std::vector<statistics::Histogram *>());
m_missTypeMachLatencyHistSeqr
.push_back(std::vector<Stats::Histogram *>());
.push_back(std::vector<statistics::Histogram *>());
m_missTypeMachLatencyHistCoalsr
.push_back(std::vector<Stats::Histogram *>());
.push_back(std::vector<statistics::Histogram *>());
for (int j = 0; j < MachineType_NUM; j++) {
m_hitTypeMachLatencyHistSeqr[i]
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_hitTypeMachLatencyHistSeqr[i][j]
->init(10)
.name(csprintf("%s.%s.hit_type_mach_latency_hist_seqr",
RubyRequestType(i), MachineType(j)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf |
statistics::oneline);
m_missTypeMachLatencyHistSeqr[i]
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_missTypeMachLatencyHistSeqr[i][j]
->init(10)
.name(csprintf("%s.%s.miss_type_mach_latency_hist_seqr",
RubyRequestType(i), MachineType(j)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf |
statistics::oneline);
m_missTypeMachLatencyHistCoalsr[i]
.push_back(new Stats::Histogram(this));
.push_back(new statistics::Histogram(this));
m_missTypeMachLatencyHistCoalsr[i][j]
->init(10)
.name(csprintf("%s.%s.miss_type_mach_latency_hist_coalsr",
RubyRequestType(i), MachineType(j)))
.desc("")
.flags(Stats::nozero | Stats::pdf | Stats::oneline);
.flags(statistics::nozero | statistics::pdf |
statistics::oneline);
}
}
}

77
src/mem/ruby/profiler/Profiler.hh
View File

@@ -91,93 +91,96 @@ class Profiler
AddressProfiler* m_address_profiler_ptr;
AddressProfiler* m_inst_profiler_ptr;
struct ProfilerStats : public Stats::Group
struct ProfilerStats : public statistics::Group
{
ProfilerStats(Stats::Group *parent, Profiler *profiler);
ProfilerStats(statistics::Group *parent, Profiler *profiler);
struct PerRequestTypeStats : public Stats::Group
struct PerRequestTypeStats : public statistics::Group
{
PerRequestTypeStats(Stats::Group *parent);
PerRequestTypeStats(statistics::Group *parent);
// Histogram of the latency of each request type
std::vector<Stats::Histogram *> m_typeLatencyHistSeqr;
std::vector<Stats::Histogram *> m_typeLatencyHistCoalsr;
std::vector<statistics::Histogram *> m_typeLatencyHistSeqr;
std::vector<statistics::Histogram *> m_typeLatencyHistCoalsr;
// Histogram of the latency of requests that hit in the controller
// connected to this sequencer for each type of request
std::vector<Stats::Histogram *> m_hitTypeLatencyHistSeqr;
std::vector<statistics::Histogram *> m_hitTypeLatencyHistSeqr;
// Histogram of the latency of requests that miss in the controller
// connected to this sequencer for each type of request
std::vector<Stats::Histogram *> m_missTypeLatencyHistSeqr;
std::vector<Stats::Histogram *> m_missTypeLatencyHistCoalsr;
std::vector<statistics::Histogram *> m_missTypeLatencyHistSeqr;
std::vector<statistics::Histogram *> m_missTypeLatencyHistCoalsr;
} perRequestTypeStats;
struct PerMachineTypeStats : public Stats::Group
struct PerMachineTypeStats : public statistics::Group
{
PerMachineTypeStats(Stats::Group *parent);
PerMachineTypeStats(statistics::Group *parent);
//! Histograms for profiling the latencies for requests that
//! did not required external messages.
std::vector<Stats::Histogram *> m_hitMachLatencyHistSeqr;
std::vector<statistics::Histogram *> m_hitMachLatencyHistSeqr;
//! Histograms for profiling the latencies for requests that
//! required external messages.
std::vector<Stats::Histogram *> m_missMachLatencyHistSeqr;
std::vector<Stats::Histogram *> m_missMachLatencyHistCoalsr;
std::vector<statistics::Histogram *> m_missMachLatencyHistSeqr;
std::vector<statistics::Histogram *> m_missMachLatencyHistCoalsr;
//! Histograms for recording the breakdown of miss latency
std::vector<Stats::Histogram *> m_IssueToInitialDelayHistSeqr;
std::vector<Stats::Histogram *> m_InitialToForwardDelayHistSeqr;
std::vector<Stats::Histogram *>
std::vector<statistics::Histogram *> m_IssueToInitialDelayHistSeqr;
std::vector<statistics::Histogram *>
m_InitialToForwardDelayHistSeqr;
std::vector<statistics::Histogram *>
m_ForwardToFirstResponseDelayHistSeqr;
std::vector<Stats::Histogram *>
std::vector<statistics::Histogram *>
m_FirstResponseToCompletionDelayHistSeqr;
std::vector<Stats::Scalar *> m_IncompleteTimesSeqr;
std::vector<Stats::Histogram *> m_IssueToInitialDelayHistCoalsr;
std::vector<Stats::Histogram *> m_InitialToForwardDelayHistCoalsr;
std::vector<Stats::Histogram *>
std::vector<statistics::Scalar *> m_IncompleteTimesSeqr;
std::vector<statistics::Histogram *>
m_IssueToInitialDelayHistCoalsr;
std::vector<statistics::Histogram *>
m_InitialToForwardDelayHistCoalsr;
std::vector<statistics::Histogram *>
m_ForwardToFirstResponseDelayHistCoalsr;
std::vector<Stats::Histogram *>
std::vector<statistics::Histogram *>
m_FirstResponseToCompletionDelayHistCoalsr;
} perMachineTypeStats;
struct PerRequestTypeMachineTypeStats : public Stats::Group
struct PerRequestTypeMachineTypeStats : public statistics::Group
{
PerRequestTypeMachineTypeStats(Stats::Group *parent);
PerRequestTypeMachineTypeStats(statistics::Group *parent);
//! Histograms for profiling the latencies for requests that
//! did not required external messages.
std::vector< std::vector<Stats::Histogram *> >
std::vector< std::vector<statistics::Histogram *> >
m_hitTypeMachLatencyHistSeqr;
//! Histograms for profiling the latencies for requests that
//! required external messages.
std::vector< std::vector<Stats::Histogram *> >
std::vector< std::vector<statistics::Histogram *> >
m_missTypeMachLatencyHistSeqr;
std::vector< std::vector<Stats::Histogram *> >
std::vector< std::vector<statistics::Histogram *> >
m_missTypeMachLatencyHistCoalsr;
} perRequestTypeMachineTypeStats;
Stats::Histogram delayHistogram;
std::vector<Stats::Histogram *> delayVCHistogram;
statistics::Histogram delayHistogram;
std::vector<statistics::Histogram *> delayVCHistogram;
//! Histogram for number of outstanding requests per cycle.
Stats::Histogram m_outstandReqHistSeqr;
Stats::Histogram m_outstandReqHistCoalsr;
statistics::Histogram m_outstandReqHistSeqr;
statistics::Histogram m_outstandReqHistCoalsr;
//! Histogram for holding latency profile of all requests.
Stats::Histogram m_latencyHistSeqr;
Stats::Histogram m_latencyHistCoalsr;
statistics::Histogram m_latencyHistSeqr;
statistics::Histogram m_latencyHistCoalsr;
//! Histogram for holding latency profile of all requests that
//! hit in the controller connected to this sequencer.
Stats::Histogram m_hitLatencyHistSeqr;
statistics::Histogram m_hitLatencyHistSeqr;
//! Histogram for holding latency profile of all requests that
//! miss in the controller connected to this sequencer.
Stats::Histogram m_missLatencyHistSeqr;
Stats::Histogram m_missLatencyHistCoalsr;
statistics::Histogram m_missLatencyHistSeqr;
statistics::Histogram m_missLatencyHistCoalsr;
};
//added by SS

12
src/mem/ruby/slicc_interface/AbstractController.cc
View File

@@ -62,7 +62,7 @@ AbstractController::AbstractController(const Params &p)
if (m_version == 0) {
// Combine the statistics from all controllers
// of this particular type.
Stats::registerDumpCallback([this]() { collateStats(); });
statistics::registerDumpCallback([this]() { collateStats(); });
}
}
@@ -72,7 +72,7 @@ AbstractController::init()
stats.delayHistogram.init(10);
uint32_t size = Network::getNumberOfVirtualNetworks();
for (uint32_t i = 0; i < size; i++) {
stats.delayVCHistogram.push_back(new Stats::Histogram(this));
stats.delayVCHistogram.push_back(new statistics::Histogram(this));
stats.delayVCHistogram[i]->init(10);
}
@@ -446,14 +446,14 @@ AbstractController::MemoryPort::MemoryPort(const std::string &_name,
}
AbstractController::
ControllerStats::ControllerStats(Stats::Group *parent)
: Stats::Group(parent),
ControllerStats::ControllerStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(fullyBusyCycles,
"cycles for which number of transistions == max transitions"),
ADD_STAT(delayHistogram, "delay_histogram")
{
fullyBusyCycles
.flags(Stats::nozero);
.flags(statistics::nozero);
delayHistogram
.flags(Stats::nozero);
.flags(statistics::nozero);
}

24
src/mem/ruby/slicc_interface/AbstractController.hh
View File

@@ -168,8 +168,8 @@ class AbstractController : public ClockedObject, public Consumer
MachineID getMachineID() const { return m_machineID; }
RequestorID getRequestorId() const { return m_id; }
Stats::Histogram& getDelayHist() { return stats.delayHistogram; }
Stats::Histogram& getDelayVCHist(uint32_t index)
statistics::Histogram& getDelayHist() { return stats.delayHistogram; }
statistics::Histogram& getDelayVCHist(uint32_t index)
{ return *(stats.delayVCHistogram[index]); }
bool respondsTo(Addr addr)
@@ -370,30 +370,30 @@ class AbstractController : public ClockedObject, public Consumer
NetDest downstreamDestinations;
public:
struct ControllerStats : public Stats::Group
struct ControllerStats : public statistics::Group
{
ControllerStats(Stats::Group *parent);
ControllerStats(statistics::Group *parent);
// Initialized by the SLICC compiler for all combinations of event and
// states. Only histograms with samples will appear in the stats
std::vector<std::vector<std::vector<Stats::Histogram*>>>
std::vector<std::vector<std::vector<statistics::Histogram*>>>
inTransLatHist;
std::vector<Stats::Scalar*> inTransLatRetries;
std::vector<Stats::Scalar*> inTransLatTotal;
std::vector<statistics::Scalar*> inTransLatRetries;
std::vector<statistics::Scalar*> inTransLatTotal;
// Initialized by the SLICC compiler for all events.
// Only histograms with samples will appear in the stats.
std::vector<Stats::Histogram*> outTransLatHist;
std::vector<Stats::Scalar*> outTransLatHistRetries;
std::vector<statistics::Histogram*> outTransLatHist;
std::vector<statistics::Scalar*> outTransLatHistRetries;
//! Counter for the number of cycles when the transitions carried out
//! were equal to the maximum allowed
Stats::Scalar fullyBusyCycles;
statistics::Scalar fullyBusyCycles;
//! Histogram for profiling delay for the messages this controller
//! cares for
Stats::Histogram delayHistogram;
std::vector<Stats::Histogram *> delayVCHistogram;
statistics::Histogram delayHistogram;
std::vector<statistics::Histogram *> delayVCHistogram;
} stats;
};

38
src/mem/ruby/structures/CacheMemory.cc
View File

@@ -515,8 +515,8 @@ CacheMemory::isLocked(Addr address, int context)
}
CacheMemory::
CacheMemoryStats::CacheMemoryStats(Stats::Group *parent)
: Stats::Group(parent),
CacheMemoryStats::CacheMemoryStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(numDataArrayReads, "Number of data array reads"),
ADD_STAT(numDataArrayWrites, "Number of data array writes"),
ADD_STAT(numTagArrayReads, "Number of tag array reads"),
@@ -541,56 +541,60 @@ CacheMemoryStats::CacheMemoryStats(Stats::Group *parent)
ADD_STAT(m_accessModeType, "")
{
numDataArrayReads
.flags(Stats::nozero);
.flags(statistics::nozero);
numDataArrayWrites
.flags(Stats::nozero);
.flags(statistics::nozero);
numTagArrayReads
.flags(Stats::nozero);
.flags(statistics::nozero);
numTagArrayWrites
.flags(Stats::nozero);
.flags(statistics::nozero);
numTagArrayStalls
.flags(Stats::nozero);
.flags(statistics::nozero);
numDataArrayStalls
.flags(Stats::nozero);
.flags(statistics::nozero);
htmTransCommitReadSet
.init(8)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan);
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan);
htmTransCommitWriteSet
.init(8)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan);
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan);
htmTransAbortReadSet
.init(8)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan);
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan);
htmTransAbortWriteSet
.init(8)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan);
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan);
m_prefetch_hits
.flags(Stats::nozero);
.flags(statistics::nozero);
m_prefetch_misses
.flags(Stats::nozero);
.flags(statistics::nozero);
m_prefetch_accesses
.flags(Stats::nozero);
.flags(statistics::nozero);
m_accessModeType
.init(RubyRequestType_NUM)
.flags(Stats::pdf | Stats::total);
.flags(statistics::pdf | statistics::total);
for (int i = 0; i < RubyAccessMode_NUM; i++) {
m_accessModeType
.subname(i, RubyAccessMode_to_string(RubyAccessMode(i)))
.flags(Stats::nozero)
.flags(statistics::nozero)
;
}
}

38
src/mem/ruby/structures/CacheMemory.hh
View File

@@ -206,33 +206,33 @@ class CacheMemory : public SimObject
bool m_use_occupancy;
private:
struct CacheMemoryStats : public Stats::Group
struct CacheMemoryStats : public statistics::Group
{
CacheMemoryStats(Stats::Group *parent);
CacheMemoryStats(statistics::Group *parent);
Stats::Scalar numDataArrayReads;
Stats::Scalar numDataArrayWrites;
Stats::Scalar numTagArrayReads;
Stats::Scalar numTagArrayWrites;
statistics::Scalar numDataArrayReads;
statistics::Scalar numDataArrayWrites;
statistics::Scalar numTagArrayReads;
statistics::Scalar numTagArrayWrites;
Stats::Scalar numTagArrayStalls;
Stats::Scalar numDataArrayStalls;
statistics::Scalar numTagArrayStalls;
statistics::Scalar numDataArrayStalls;
// hardware transactional memory
Stats::Histogram htmTransCommitReadSet;
Stats::Histogram htmTransCommitWriteSet;
Stats::Histogram htmTransAbortReadSet;
Stats::Histogram htmTransAbortWriteSet;
statistics::Histogram htmTransCommitReadSet;
statistics::Histogram htmTransCommitWriteSet;
statistics::Histogram htmTransAbortReadSet;
statistics::Histogram htmTransAbortWriteSet;
Stats::Scalar m_demand_hits;
Stats::Scalar m_demand_misses;
Stats::Formula m_demand_accesses;
statistics::Scalar m_demand_hits;
statistics::Scalar m_demand_misses;
statistics::Formula m_demand_accesses;
Stats::Scalar m_prefetch_hits;
Stats::Scalar m_prefetch_misses;
Stats::Formula m_prefetch_accesses;
statistics::Scalar m_prefetch_hits;
statistics::Scalar m_prefetch_misses;
statistics::Formula m_prefetch_accesses;
Stats::Vector m_accessModeType;
statistics::Vector m_accessModeType;
} cacheMemoryStats;
public:

4
src/mem/ruby/structures/RubyPrefetcher.cc
View File

@@ -64,8 +64,8 @@ RubyPrefetcher::RubyPrefetcher(const Params &p)
}
RubyPrefetcher::
RubyPrefetcherStats::RubyPrefetcherStats(Stats::Group *parent)
: Stats::Group(parent, "RubyPrefetcher"),
RubyPrefetcherStats::RubyPrefetcherStats(statistics::Group *parent)
: statistics::Group(parent, "RubyPrefetcher"),
ADD_STAT(numMissObserved, "Number of misses observed"),
ADD_STAT(numAllocatedStreams, "Number of streams allocated for "
"prefetching"),

18
src/mem/ruby/structures/RubyPrefetcher.hh
View File

@@ -234,24 +234,24 @@ class RubyPrefetcher : public SimObject
const Addr m_page_shift;
struct RubyPrefetcherStats : public Stats::Group
struct RubyPrefetcherStats : public statistics::Group
{
RubyPrefetcherStats(Stats::Group *parent);
RubyPrefetcherStats(statistics::Group *parent);
//! Count of accesses to the prefetcher
Stats::Scalar numMissObserved;
statistics::Scalar numMissObserved;
//! Count of prefetch streams allocated
Stats::Scalar numAllocatedStreams;
statistics::Scalar numAllocatedStreams;
//! Count of prefetch requests made
Stats::Scalar numPrefetchRequested;
statistics::Scalar numPrefetchRequested;
//! Count of successful prefetches
Stats::Scalar numHits;
statistics::Scalar numHits;
//! Count of partial successful prefetches
Stats::Scalar numPartialHits;
statistics::Scalar numPartialHits;
//! Count of pages crossed
Stats::Scalar numPagesCrossed;
statistics::Scalar numPagesCrossed;
//! Count of misses incurred for blocks that were prefetched
Stats::Scalar numMissedPrefetchedBlocks;
statistics::Scalar numMissedPrefetchedBlocks;
} rubyPrefetcherStats;
};

6
src/mem/ruby/structures/TBEStorage.cc
View File

@@ -37,15 +37,15 @@
#include <mem/ruby/structures/TBEStorage.hh>
TBEStorage::TBEStorage(Stats::Group *parent, int number_of_TBEs)
TBEStorage::TBEStorage(statistics::Group *parent, int number_of_TBEs)
: m_reserved(0), m_stats(parent)
{
for (int i = 0; i < number_of_TBEs; ++i)
m_slots_avail.push(i);
}
TBEStorage::TBEStorageStats::TBEStorageStats(Stats::Group *parent)
: Stats::Group(parent),
TBEStorage::TBEStorageStats::TBEStorageStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(avg_size, "Avg. number of slots allocated"),
ADD_STAT(avg_util, "Avg. utilization"),
ADD_STAT(avg_reserved, "Avg. number of slots reserved")

12
src/mem/ruby/structures/TBEStorage.hh
View File

@@ -73,7 +73,7 @@
class TBEStorage
{
public:
TBEStorage(Stats::Group *parent, int number_of_TBEs);
TBEStorage(statistics::Group *parent, int number_of_TBEs);
// Returns the current number of slots allocated
int size() const { return m_slots_used.size(); }
@@ -118,14 +118,14 @@ class TBEStorage
std::stack<int> m_slots_avail;
std::unordered_map<int, int> m_slots_used;
struct TBEStorageStats : public Stats::Group
struct TBEStorageStats : public statistics::Group
{
TBEStorageStats(Stats::Group *parent);
TBEStorageStats(statistics::Group *parent);
// Statistical variables
Stats::Average avg_size;
Stats::Average avg_util;
Stats::Average avg_reserved;
statistics::Average avg_size;
statistics::Average avg_util;
statistics::Average avg_reserved;
} m_stats;
};

22
src/mem/ruby/system/GPUCoalescer.cc
View File

@@ -222,35 +222,39 @@ GPUCoalescer::GPUCoalescer(const Params &p)
m_missLatencyHist.init(10);
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_typeLatencyHist.push_back(new Stats::Histogram());
m_typeLatencyHist.push_back(new statistics::Histogram());
m_typeLatencyHist[i]->init(10);
m_missTypeLatencyHist.push_back(new Stats::Histogram());
m_missTypeLatencyHist.push_back(new statistics::Histogram());
m_missTypeLatencyHist[i]->init(10);
}
for (int i = 0; i < MachineType_NUM; i++) {
m_missMachLatencyHist.push_back(new Stats::Histogram());
m_missMachLatencyHist.push_back(new statistics::Histogram());
m_missMachLatencyHist[i]->init(10);
m_IssueToInitialDelayHist.push_back(new Stats::Histogram());
m_IssueToInitialDelayHist.push_back(new statistics::Histogram());
m_IssueToInitialDelayHist[i]->init(10);
m_InitialToForwardDelayHist.push_back(new Stats::Histogram());
m_InitialToForwardDelayHist.push_back(new statistics::Histogram());
m_InitialToForwardDelayHist[i]->init(10);
m_ForwardToFirstResponseDelayHist.push_back(new Stats::Histogram());
m_ForwardToFirstResponseDelayHist.push_back(
new statistics::Histogram());
m_ForwardToFirstResponseDelayHist[i]->init(10);
m_FirstResponseToCompletionDelayHist.push_back(new Stats::Histogram());
m_FirstResponseToCompletionDelayHist.push_back(
new statistics::Histogram());
m_FirstResponseToCompletionDelayHist[i]->init(10);
}
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_missTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>());
m_missTypeMachLatencyHist.push_back(
std::vector<statistics::Histogram *>());
for (int j = 0; j < MachineType_NUM; j++) {
m_missTypeMachLatencyHist[i].push_back(new Stats::Histogram());
m_missTypeMachLatencyHist[i].push_back(
new statistics::Histogram());
m_missTypeMachLatencyHist[i][j]->init(10);
}
}

99
src/mem/ruby/system/GPUCoalescer.hh
View File

@@ -333,36 +333,36 @@ class GPUCoalescer : public RubyPort
GMTokenPort& getGMTokenPort() { return gmTokenPort; }
Stats::Histogram& getOutstandReqHist() { return m_outstandReqHist; }
statistics::Histogram& getOutstandReqHist() { return m_outstandReqHist; }
Stats::Histogram& getLatencyHist() { return m_latencyHist; }
Stats::Histogram& getTypeLatencyHist(uint32_t t)
statistics::Histogram& getLatencyHist() { return m_latencyHist; }
statistics::Histogram& getTypeLatencyHist(uint32_t t)
{ return *m_typeLatencyHist[t]; }
Stats::Histogram& getMissLatencyHist()
statistics::Histogram& getMissLatencyHist()
{ return m_missLatencyHist; }
Stats::Histogram& getMissTypeLatencyHist(uint32_t t)
statistics::Histogram& getMissTypeLatencyHist(uint32_t t)
{ return *m_missTypeLatencyHist[t]; }
Stats::Histogram& getMissMachLatencyHist(uint32_t t) const
statistics::Histogram& getMissMachLatencyHist(uint32_t t) const
{ return *m_missMachLatencyHist[t]; }
Stats::Histogram&
statistics::Histogram&
getMissTypeMachLatencyHist(uint32_t r, uint32_t t) const
{ return *m_missTypeMachLatencyHist[r][t]; }
Stats::Histogram& getIssueToInitialDelayHist(uint32_t t) const
statistics::Histogram& getIssueToInitialDelayHist(uint32_t t) const
{ return *m_IssueToInitialDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getInitialToForwardDelayHist(const MachineType t) const
{ return *m_InitialToForwardDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getForwardRequestToFirstResponseHist(const MachineType t) const
{ return *m_ForwardToFirstResponseDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getFirstResponseToCompletionDelayHist(const MachineType t) const
{ return *m_FirstResponseToCompletionDelayHist[t]; }
@@ -458,63 +458,64 @@ class GPUCoalescer : public RubyPort
// TODO - Need to update the following stats once the VIPER protocol
// is re-integrated.
// // m5 style stats for TCP hit/miss counts
// Stats::Scalar GPU_TCPLdHits;
// Stats::Scalar GPU_TCPLdTransfers;
// Stats::Scalar GPU_TCCLdHits;
// Stats::Scalar GPU_LdMiss;
// statistics::Scalar GPU_TCPLdHits;
// statistics::Scalar GPU_TCPLdTransfers;
// statistics::Scalar GPU_TCCLdHits;
// statistics::Scalar GPU_LdMiss;
//
// Stats::Scalar GPU_TCPStHits;
// Stats::Scalar GPU_TCPStTransfers;
// Stats::Scalar GPU_TCCStHits;
// Stats::Scalar GPU_StMiss;
// statistics::Scalar GPU_TCPStHits;
// statistics::Scalar GPU_TCPStTransfers;
// statistics::Scalar GPU_TCCStHits;
// statistics::Scalar GPU_StMiss;
//
// Stats::Scalar CP_TCPLdHits;
// Stats::Scalar CP_TCPLdTransfers;
// Stats::Scalar CP_TCCLdHits;
// Stats::Scalar CP_LdMiss;
// statistics::Scalar CP_TCPLdHits;
// statistics::Scalar CP_TCPLdTransfers;
// statistics::Scalar CP_TCCLdHits;
// statistics::Scalar CP_LdMiss;
//
// Stats::Scalar CP_TCPStHits;
// Stats::Scalar CP_TCPStTransfers;
// Stats::Scalar CP_TCCStHits;
// Stats::Scalar CP_StMiss;
// statistics::Scalar CP_TCPStHits;
// statistics::Scalar CP_TCPStTransfers;
// statistics::Scalar CP_TCCStHits;
// statistics::Scalar CP_StMiss;
//! Histogram for number of outstanding requests per cycle.
Stats::Histogram m_outstandReqHist;
statistics::Histogram m_outstandReqHist;
//! Histogram for holding latency profile of all requests.
Stats::Histogram m_latencyHist;
std::vector<Stats::Histogram *> m_typeLatencyHist;
statistics::Histogram m_latencyHist;
std::vector<statistics::Histogram *> m_typeLatencyHist;
//! Histogram for holding latency profile of all requests that
//! miss in the controller connected to this sequencer.
Stats::Histogram m_missLatencyHist;
std::vector<Stats::Histogram *> m_missTypeLatencyHist;
statistics::Histogram m_missLatencyHist;
std::vector<statistics::Histogram *> m_missTypeLatencyHist;
//! Histograms for profiling the latencies for requests that
//! required external messages.
std::vector<Stats::Histogram *> m_missMachLatencyHist;
std::vector< std::vector<Stats::Histogram *> > m_missTypeMachLatencyHist;
std::vector<statistics::Histogram *> m_missMachLatencyHist;
std::vector<std::vector<statistics::Histogram *>>
m_missTypeMachLatencyHist;
//! Histograms for recording the breakdown of miss latency
std::vector<Stats::Histogram *> m_IssueToInitialDelayHist;
std::vector<Stats::Histogram *> m_InitialToForwardDelayHist;
std::vector<Stats::Histogram *> m_ForwardToFirstResponseDelayHist;
std::vector<Stats::Histogram *> m_FirstResponseToCompletionDelayHist;
std::vector<statistics::Histogram *> m_IssueToInitialDelayHist;
std::vector<statistics::Histogram *> m_InitialToForwardDelayHist;
std::vector<statistics::Histogram *> m_ForwardToFirstResponseDelayHist;
std::vector<statistics::Histogram *> m_FirstResponseToCompletionDelayHist;
// TODO - Need to update the following stats once the VIPER protocol
// is re-integrated.
// Stats::Distribution numHopDelays;
// Stats::Distribution tcpToTccDelay;
// Stats::Distribution tccToSdDelay;
// Stats::Distribution sdToSdDelay;
// Stats::Distribution sdToTccDelay;
// Stats::Distribution tccToTcpDelay;
// statistics::Distribution numHopDelays;
// statistics::Distribution tcpToTccDelay;
// statistics::Distribution tccToSdDelay;
// statistics::Distribution sdToSdDelay;
// statistics::Distribution sdToTccDelay;
// statistics::Distribution tccToTcpDelay;
//
// Stats::Average avgTcpToTcc;
// Stats::Average avgTccToSd;
// Stats::Average avgSdToSd;
// Stats::Average avgSdToTcc;
// Stats::Average avgTccToTcp;
// statistics::Average avgTcpToTcc;
// statistics::Average avgTccToSd;
// statistics::Average avgSdToSd;
// statistics::Average avgSdToTcc;
// statistics::Average avgTccToTcp;
private:
// Token port is used to send/receive tokens to/from GPU's global memory

18
src/mem/ruby/system/HTMSequencer.cc
View File

@@ -74,16 +74,19 @@ HTMSequencer::HTMSequencer(const RubyHTMSequencerParams &p)
// hardware transactional memory
m_htm_transaction_cycles
.init(10)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan)
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan)
;
m_htm_transaction_instructions
.init(10)
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan)
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan)
;
auto num_causes = static_cast<int>(HtmFailureFaultCause::NUM_CAUSES);
m_htm_transaction_abort_cause
.init(num_causes)
.flags(Stats::total | Stats::pdf | Stats::dist | Stats::nozero)
.flags(statistics::total | statistics::pdf | statistics::dist |
statistics::nozero)
;
for (unsigned cause_idx = 0; cause_idx < num_causes; ++cause_idx) {
@@ -208,20 +211,23 @@ HTMSequencer::regStats()
.init(10)
.name(name() + ".htm_transaction_cycles")
.desc("number of cycles spent in an outer transaction")
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan)
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan)
;
m_htm_transaction_instructions
.init(10)
.name(name() + ".htm_transaction_instructions")
.desc("number of instructions spent in an outer transaction")
.flags(Stats::pdf | Stats::dist | Stats::nozero | Stats::nonan)
.flags(statistics::pdf | statistics::dist | statistics::nozero |
statistics::nonan)
;
auto num_causes = static_cast<int>(HtmFailureFaultCause::NUM_CAUSES);
m_htm_transaction_abort_cause
.init(num_causes)
.name(name() + ".htm_transaction_abort_cause")
.desc("cause of htm transaction abort")
.flags(Stats::total | Stats::pdf | Stats::dist | Stats::nozero)
.flags(statistics::total | statistics::pdf | statistics::dist |
statistics::nozero)
;
for (unsigned cause_idx = 0; cause_idx < num_causes; ++cause_idx) {

6
src/mem/ruby/system/HTMSequencer.hh
View File

@@ -95,11 +95,11 @@ class HTMSequencer : public Sequencer
Counter m_htmstart_instruction;
//! Histogram of cycle latencies of HTM transactions
Stats::Histogram m_htm_transaction_cycles;
statistics::Histogram m_htm_transaction_cycles;
//! Histogram of instruction lengths of HTM transactions
Stats::Histogram m_htm_transaction_instructions;
statistics::Histogram m_htm_transaction_instructions;
//! Causes for HTM transaction aborts
Stats::Vector m_htm_transaction_abort_cause;
statistics::Vector m_htm_transaction_abort_cause;
};
inline std::ostream&

2
src/mem/ruby/system/RubySystem.cc
View File

@@ -85,7 +85,7 @@ RubySystem::RubySystem(const Params &p)
m_abstract_controls.resize(MachineType_NUM);
// Collate the statistics before they are printed.
Stats::registerDumpCallback([this]() { collateStats(); });
statistics::registerDumpCallback([this]() { collateStats(); });
// Create the profiler
m_profiler = new Profiler(p, this);
m_phys_mem = p.phys_mem;

31
src/mem/ruby/system/Sequencer.cc
View File

@@ -85,45 +85,50 @@ Sequencer::Sequencer(const Params &p)
m_missLatencyHist.init(10);
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_typeLatencyHist.push_back(new Stats::Histogram());
m_typeLatencyHist.push_back(new statistics::Histogram());
m_typeLatencyHist[i]->init(10);
m_hitTypeLatencyHist.push_back(new Stats::Histogram());
m_hitTypeLatencyHist.push_back(new statistics::Histogram());
m_hitTypeLatencyHist[i]->init(10);
m_missTypeLatencyHist.push_back(new Stats::Histogram());
m_missTypeLatencyHist.push_back(new statistics::Histogram());
m_missTypeLatencyHist[i]->init(10);
}
for (int i = 0; i < MachineType_NUM; i++) {
m_hitMachLatencyHist.push_back(new Stats::Histogram());
m_hitMachLatencyHist.push_back(new statistics::Histogram());
m_hitMachLatencyHist[i]->init(10);
m_missMachLatencyHist.push_back(new Stats::Histogram());
m_missMachLatencyHist.push_back(new statistics::Histogram());
m_missMachLatencyHist[i]->init(10);
m_IssueToInitialDelayHist.push_back(new Stats::Histogram());
m_IssueToInitialDelayHist.push_back(new statistics::Histogram());
m_IssueToInitialDelayHist[i]->init(10);
m_InitialToForwardDelayHist.push_back(new Stats::Histogram());
m_InitialToForwardDelayHist.push_back(new statistics::Histogram());
m_InitialToForwardDelayHist[i]->init(10);
m_ForwardToFirstResponseDelayHist.push_back(new Stats::Histogram());
m_ForwardToFirstResponseDelayHist.push_back(
new statistics::Histogram());
m_ForwardToFirstResponseDelayHist[i]->init(10);
m_FirstResponseToCompletionDelayHist.push_back(new Stats::Histogram());
m_FirstResponseToCompletionDelayHist.push_back(
new statistics::Histogram());
m_FirstResponseToCompletionDelayHist[i]->init(10);
}
for (int i = 0; i < RubyRequestType_NUM; i++) {
m_hitTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>());
m_missTypeMachLatencyHist.push_back(std::vector<Stats::Histogram *>());
m_hitTypeMachLatencyHist.push_back(
std::vector<statistics::Histogram *>());
m_missTypeMachLatencyHist.push_back(
std::vector<statistics::Histogram *>());
for (int j = 0; j < MachineType_NUM; j++) {
m_hitTypeMachLatencyHist[i].push_back(new Stats::Histogram());
m_hitTypeMachLatencyHist[i].push_back(new statistics::Histogram());
m_hitTypeMachLatencyHist[i][j]->init(10);
m_missTypeMachLatencyHist[i].push_back(new Stats::Histogram());
m_missTypeMachLatencyHist[i].push_back(
new statistics::Histogram());
m_missTypeMachLatencyHist[i][j]->init(10);
}
}

65
src/mem/ruby/system/Sequencer.hh
View File

@@ -139,50 +139,50 @@ class Sequencer : public RubyPort
virtual int functionalWrite(Packet *func_pkt) override;
void recordRequestType(SequencerRequestType requestType);
Stats::Histogram& getOutstandReqHist() { return m_outstandReqHist; }
statistics::Histogram& getOutstandReqHist() { return m_outstandReqHist; }
Stats::Histogram& getLatencyHist() { return m_latencyHist; }
Stats::Histogram& getTypeLatencyHist(uint32_t t)
statistics::Histogram& getLatencyHist() { return m_latencyHist; }
statistics::Histogram& getTypeLatencyHist(uint32_t t)
{ return *m_typeLatencyHist[t]; }
Stats::Histogram& getHitLatencyHist() { return m_hitLatencyHist; }
Stats::Histogram& getHitTypeLatencyHist(uint32_t t)
statistics::Histogram& getHitLatencyHist() { return m_hitLatencyHist; }
statistics::Histogram& getHitTypeLatencyHist(uint32_t t)
{ return *m_hitTypeLatencyHist[t]; }
Stats::Histogram& getHitMachLatencyHist(uint32_t t)
statistics::Histogram& getHitMachLatencyHist(uint32_t t)
{ return *m_hitMachLatencyHist[t]; }
Stats::Histogram& getHitTypeMachLatencyHist(uint32_t r, uint32_t t)
statistics::Histogram& getHitTypeMachLatencyHist(uint32_t r, uint32_t t)
{ return *m_hitTypeMachLatencyHist[r][t]; }
Stats::Histogram& getMissLatencyHist()
statistics::Histogram& getMissLatencyHist()
{ return m_missLatencyHist; }
Stats::Histogram& getMissTypeLatencyHist(uint32_t t)
statistics::Histogram& getMissTypeLatencyHist(uint32_t t)
{ return *m_missTypeLatencyHist[t]; }
Stats::Histogram& getMissMachLatencyHist(uint32_t t) const
statistics::Histogram& getMissMachLatencyHist(uint32_t t) const
{ return *m_missMachLatencyHist[t]; }
Stats::Histogram&
statistics::Histogram&
getMissTypeMachLatencyHist(uint32_t r, uint32_t t) const
{ return *m_missTypeMachLatencyHist[r][t]; }
Stats::Histogram& getIssueToInitialDelayHist(uint32_t t) const
statistics::Histogram& getIssueToInitialDelayHist(uint32_t t) const
{ return *m_IssueToInitialDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getInitialToForwardDelayHist(const MachineType t) const
{ return *m_InitialToForwardDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getForwardRequestToFirstResponseHist(const MachineType t) const
{ return *m_ForwardToFirstResponseDelayHist[t]; }
Stats::Histogram&
statistics::Histogram&
getFirstResponseToCompletionDelayHist(const MachineType t) const
{ return *m_FirstResponseToCompletionDelayHist[t]; }
Stats::Counter getIncompleteTimes(const MachineType t) const
statistics::Counter getIncompleteTimes(const MachineType t) const
{ return m_IncompleteTimes[t]; }
private:
@@ -237,38 +237,39 @@ class Sequencer : public RubyPort
bool m_runningGarnetStandalone;
//! Histogram for number of outstanding requests per cycle.
Stats::Histogram m_outstandReqHist;
statistics::Histogram m_outstandReqHist;
//! Histogram for holding latency profile of all requests.
Stats::Histogram m_latencyHist;
std::vector<Stats::Histogram *> m_typeLatencyHist;
statistics::Histogram m_latencyHist;
std::vector<statistics::Histogram *> m_typeLatencyHist;
//! Histogram for holding latency profile of all requests that
//! hit in the controller connected to this sequencer.
Stats::Histogram m_hitLatencyHist;
std::vector<Stats::Histogram *> m_hitTypeLatencyHist;
statistics::Histogram m_hitLatencyHist;
std::vector<statistics::Histogram *> m_hitTypeLatencyHist;
//! Histograms for profiling the latencies for requests that
//! did not required external messages.
std::vector<Stats::Histogram *> m_hitMachLatencyHist;
std::vector< std::vector<Stats::Histogram *> > m_hitTypeMachLatencyHist;
std::vector<statistics::Histogram *> m_hitMachLatencyHist;
std::vector<std::vector<statistics::Histogram *>> m_hitTypeMachLatencyHist;
//! Histogram for holding latency profile of all requests that
//! miss in the controller connected to this sequencer.
Stats::Histogram m_missLatencyHist;
std::vector<Stats::Histogram *> m_missTypeLatencyHist;
statistics::Histogram m_missLatencyHist;
std::vector<statistics::Histogram *> m_missTypeLatencyHist;
//! Histograms for profiling the latencies for requests that
//! required external messages.
std::vector<Stats::Histogram *> m_missMachLatencyHist;
std::vector< std::vector<Stats::Histogram *> > m_missTypeMachLatencyHist;
std::vector<statistics::Histogram *> m_missMachLatencyHist;
std::vector<std::vector<statistics::Histogram *>>
m_missTypeMachLatencyHist;
//! Histograms for recording the breakdown of miss latency
std::vector<Stats::Histogram *> m_IssueToInitialDelayHist;
std::vector<Stats::Histogram *> m_InitialToForwardDelayHist;
std::vector<Stats::Histogram *> m_ForwardToFirstResponseDelayHist;
std::vector<Stats::Histogram *> m_FirstResponseToCompletionDelayHist;
std::vector<Stats::Counter> m_IncompleteTimes;
std::vector<statistics::Histogram *> m_IssueToInitialDelayHist;
std::vector<statistics::Histogram *> m_InitialToForwardDelayHist;
std::vector<statistics::Histogram *> m_ForwardToFirstResponseDelayHist;
std::vector<statistics::Histogram *> m_FirstResponseToCompletionDelayHist;
std::vector<statistics::Counter> m_IncompleteTimes;
EventFunctionWrapper deadlockCheckEvent;

55
src/mem/slicc/symbols/StateMachine.py
View File

@@ -391,8 +391,8 @@ int m_counters[${ident}_State_NUM][${ident}_Event_NUM];
int m_event_counters[${ident}_Event_NUM];
bool m_possible[${ident}_State_NUM][${ident}_Event_NUM];
static std::vector<Stats::Vector *> eventVec;
static std::vector<std::vector<Stats::Vector *> > transVec;
static std::vector<statistics::Vector *> eventVec;
static std::vector<std::vector<statistics::Vector *> > transVec;
static int m_num_controllers;
// Internal functions
@@ -536,8 +536,8 @@ void unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr);
code('''
int $c_ident::m_num_controllers = 0;
std::vector<Stats::Vector *> $c_ident::eventVec;
std::vector<std::vector<Stats::Vector *> > $c_ident::transVec;
std::vector<statistics::Vector *> $c_ident::eventVec;
std::vector<std::vector<statistics::Vector *> > $c_ident::transVec;
// for adding information to the protocol debug trace
std::stringstream ${ident}_transitionComment;
@@ -816,17 +816,17 @@ $c_ident::regStats()
if (m_version == 0) {
Profiler *profiler = params().ruby_system->getProfiler();
Stats::Group *profilerStatsPtr = &profiler->rubyProfilerStats;
statistics::Group *profilerStatsPtr = &profiler->rubyProfilerStats;
for (${ident}_Event event = ${ident}_Event_FIRST;
event < ${ident}_Event_NUM; ++event) {
std::string stat_name =
"${c_ident}." + ${ident}_Event_to_string(event);
Stats::Vector *t =
new Stats::Vector(profilerStatsPtr, stat_name.c_str());
statistics::Vector *t =
new statistics::Vector(profilerStatsPtr, stat_name.c_str());
t->init(m_num_controllers);
t->flags(Stats::pdf | Stats::total | Stats::oneline |
Stats::nozero);
t->flags(statistics::pdf | statistics::total |
statistics::oneline | statistics::nozero);
eventVec.push_back(t);
}
@@ -834,18 +834,18 @@ $c_ident::regStats()
for (${ident}_State state = ${ident}_State_FIRST;
state < ${ident}_State_NUM; ++state) {
transVec.push_back(std::vector<Stats::Vector *>());
transVec.push_back(std::vector<statistics::Vector *>());
for (${ident}_Event event = ${ident}_Event_FIRST;
event < ${ident}_Event_NUM; ++event) {
std::string stat_name = "${c_ident}." +
${ident}_State_to_string(state) +
"." + ${ident}_Event_to_string(event);
Stats::Vector *t =
new Stats::Vector(profilerStatsPtr, stat_name.c_str());
statistics::Vector *t = new statistics::Vector(
profilerStatsPtr, stat_name.c_str());
t->init(m_num_controllers);
t->flags(Stats::pdf | Stats::total | Stats::oneline |
Stats::nozero);
t->flags(statistics::pdf | statistics::total |
statistics::oneline | statistics::nozero);
transVec[state].push_back(t);
}
}
@@ -855,31 +855,32 @@ $c_ident::regStats()
event < ${ident}_Event_NUM; ++event) {
std::string stat_name =
"outTransLatHist." + ${ident}_Event_to_string(event);
Stats::Histogram* t = new Stats::Histogram(&stats, stat_name.c_str());
statistics::Histogram* t =
new statistics::Histogram(&stats, stat_name.c_str());
stats.outTransLatHist.push_back(t);
t->init(5);
t->flags(Stats::pdf | Stats::total |
Stats::oneline | Stats::nozero);
t->flags(statistics::pdf | statistics::total |
statistics::oneline | statistics::nozero);
Stats::Scalar* r = new Stats::Scalar(&stats,
statistics::Scalar* r = new statistics::Scalar(&stats,
(stat_name + ".retries").c_str());
stats.outTransLatHistRetries.push_back(r);
r->flags(Stats::nozero);
r->flags(statistics::nozero);
}
for (${ident}_Event event = ${ident}_Event_FIRST;
event < ${ident}_Event_NUM; ++event) {
std::string stat_name = ".inTransLatHist." +
${ident}_Event_to_string(event);
Stats::Scalar* r = new Stats::Scalar(&stats,
statistics::Scalar* r = new statistics::Scalar(&stats,
(stat_name + ".total").c_str());
stats.inTransLatTotal.push_back(r);
r->flags(Stats::nozero);
r->flags(statistics::nozero);
r = new Stats::Scalar(&stats,
r = new statistics::Scalar(&stats,
(stat_name + ".retries").c_str());
stats.inTransLatRetries.push_back(r);
r->flags(Stats::nozero);
r->flags(statistics::nozero);
stats.inTransLatHist.emplace_back();
for (${ident}_State initial_state = ${ident}_State_FIRST;
@@ -891,12 +892,12 @@ $c_ident::regStats()
${ident}_Event_to_string(event) + "." +
${ident}_State_to_string(initial_state) + "." +
${ident}_State_to_string(final_state);
Stats::Histogram* t =
new Stats::Histogram(&stats, stat_name.c_str());
statistics::Histogram* t =
new statistics::Histogram(&stats, stat_name.c_str());
stats.inTransLatHist.back().back().push_back(t);
t->init(5);
t->flags(Stats::pdf | Stats::total |
Stats::oneline | Stats::nozero);
t->flags(statistics::pdf | statistics::total |
statistics::oneline | statistics::nozero);
}
}
}

16
src/mem/snoop_filter.cc
View File

@@ -387,22 +387,22 @@ SnoopFilter::updateResponse(const Packet* cpkt, const ResponsePort&
__func__, sf_item.requested, sf_item.holder);
}
SnoopFilter::SnoopFilterStats::SnoopFilterStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(totRequests, Stats::units::Count::get(),
SnoopFilter::SnoopFilterStats::SnoopFilterStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(totRequests, statistics::units::Count::get(),
"Total number of requests made to the snoop filter."),
ADD_STAT(hitSingleRequests, Stats::units::Count::get(),
ADD_STAT(hitSingleRequests, statistics::units::Count::get(),
"Number of requests hitting in the snoop filter with a single "
"holder of the requested data."),
ADD_STAT(hitMultiRequests, Stats::units::Count::get(),
ADD_STAT(hitMultiRequests, statistics::units::Count::get(),
"Number of requests hitting in the snoop filter with multiple "
"(>1) holders of the requested data."),
ADD_STAT(totSnoops, Stats::units::Count::get(),
ADD_STAT(totSnoops, statistics::units::Count::get(),
"Total number of snoops made to the snoop filter."),
ADD_STAT(hitSingleSnoops, Stats::units::Count::get(),
ADD_STAT(hitSingleSnoops, statistics::units::Count::get(),
"Number of snoops hitting in the snoop filter with a single "
"holder of the requested data."),
ADD_STAT(hitMultiSnoops, Stats::units::Count::get(),
ADD_STAT(hitMultiSnoops, statistics::units::Count::get(),
"Number of snoops hitting in the snoop filter with multiple "
"(>1) holders of the requested data.")
{}

16
src/mem/snoop_filter.hh
View File

@@ -315,17 +315,17 @@ class SnoopFilter : public SimObject
};
/** Statistics */
struct SnoopFilterStats : public Stats::Group
struct SnoopFilterStats : public statistics::Group
{
SnoopFilterStats(Stats::Group *parent);
SnoopFilterStats(statistics::Group *parent);
Stats::Scalar totRequests;
Stats::Scalar hitSingleRequests;
Stats::Scalar hitMultiRequests;
statistics::Scalar totRequests;
statistics::Scalar hitSingleRequests;
statistics::Scalar hitMultiRequests;
Stats::Scalar totSnoops;
Stats::Scalar hitSingleSnoops;
Stats::Scalar hitMultiSnoops;
statistics::Scalar totSnoops;
statistics::Scalar hitSingleSnoops;
statistics::Scalar hitMultiSnoops;
} stats;
};

18
src/mem/xbar.cc
View File

@@ -63,11 +63,11 @@ BaseXBar::BaseXBar(const BaseXBarParams &p)
gotAllAddrRanges(false), defaultPortID(InvalidPortID),
useDefaultRange(p.use_default_range),
ADD_STAT(transDist, Stats::units::Count::get(),
ADD_STAT(transDist, statistics::units::Count::get(),
"Transaction distribution"),
ADD_STAT(pktCount, Stats::units::Count::get(),
ADD_STAT(pktCount, statistics::units::Count::get(),
"Packet count per connected requestor and responder"),
ADD_STAT(pktSize, Stats::units::Byte::get(),
ADD_STAT(pktSize, statistics::units::Byte::get(),
"Cumulative packet size per connected requestor and responder")
{
}
@@ -139,18 +139,18 @@ BaseXBar::calcPacketTiming(PacketPtr pkt, Tick header_delay)
template <typename SrcType, typename DstType>
BaseXBar::Layer<SrcType, DstType>::Layer(DstType& _port, BaseXBar& _xbar,
const std::string& _name) :
Stats::Group(&_xbar, _name.c_str()),
statistics::Group(&_xbar, _name.c_str()),
port(_port), xbar(_xbar), _name(xbar.name() + "." + _name), state(IDLE),
waitingForPeer(NULL), releaseEvent([this]{ releaseLayer(); }, name()),
ADD_STAT(occupancy, Stats::units::Tick::get(), "Layer occupancy (ticks)"),
ADD_STAT(utilization, Stats::units::Ratio::get(), "Layer utilization")
ADD_STAT(occupancy, statistics::units::Tick::get(), "Layer occupancy (ticks)"),
ADD_STAT(utilization, statistics::units::Ratio::get(), "Layer utilization")
{
occupancy
.flags(Stats::nozero);
.flags(statistics::nozero);
utilization
.precision(1)
.flags(Stats::nozero);
.flags(statistics::nozero);
utilization = occupancy / simTicks;
}
@@ -542,7 +542,7 @@ BaseXBar::regStats()
{
ClockedObject::regStats();
using namespace Stats;
using namespace statistics;
transDist
.init(MemCmd::NUM_MEM_CMDS)

12
src/mem/xbar.hh
View File

@@ -85,7 +85,7 @@ class BaseXBar : public ClockedObject
* CPU-side ports, whereas a response layer holds memory-side ports.
*/
template <typename SrcType, typename DstType>
class Layer : public Drainable, public Stats::Group
class Layer : public Drainable, public statistics::Group
{
public:
@@ -226,8 +226,8 @@ class BaseXBar : public ClockedObject
* the time the layer spends in the busy state and are thus only
* relevant when the memory system is in timing mode.
*/
Stats::Scalar occupancy;
Stats::Formula utilization;
statistics::Scalar occupancy;
statistics::Formula utilization;
};
@@ -396,9 +396,9 @@ class BaseXBar : public ClockedObject
* ports and neighbouring CPU-side ports), summing up both directions
* (request and response).
*/
Stats::Vector transDist;
Stats::Vector2d pktCount;
Stats::Vector2d pktSize;
statistics::Vector transDist;
statistics::Vector2d pktCount;
statistics::Vector2d pktSize;
public: