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

base-stats: Rename Units namespace as units

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

Stats::Units became Stats::units.

Change-Id: I9ce855b291db122d952098a090a2984b42152850
Signed-off-by: Daniel R. Carvalho <odanrc@yahoo.com.br>
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/45415
Maintainer: Jason Lowe-Power <power.jg@gmail.com>
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Hoa Nguyen <hoanguyen@ucdavis.edu>
This commit is contained in:
Daniel R. Carvalho
2021-05-06 15:25:50 -03:00
committed by Daniel Carvalho
parent 7592230550
commit 3016478068
73 changed files with 939 additions and 937 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/cpu/base.cc
View File

@@ -370,11 +370,11 @@ BaseCPU::probeInstCommit(const StaticInstPtr &inst, Addr pc)
BaseCPU::
BaseCPUStats::BaseCPUStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(numCycles, Stats::Units::Cycle::get(),
ADD_STAT(numCycles, Stats::units::Cycle::get(),
"Number of cpu cycles simulated"),
ADD_STAT(numWorkItemsStarted, Stats::Units::Count::get(),
ADD_STAT(numWorkItemsStarted, Stats::units::Count::get(),
"Number of work items this cpu started"),
ADD_STAT(numWorkItemsCompleted, Stats::Units::Count::get(),
ADD_STAT(numWorkItemsCompleted, Stats::units::Count::get(),
"Number of work items this cpu completed")
{
}
@@ -734,15 +734,15 @@ BaseCPU::waitForRemoteGDB() const
BaseCPU::GlobalStats::GlobalStats(::Stats::Group *parent)
: ::Stats::Group(parent),
ADD_STAT(simInsts, Stats::Units::Count::get(),
ADD_STAT(simInsts, Stats::units::Count::get(),
"Number of instructions simulated"),
ADD_STAT(simOps, Stats::Units::Count::get(),
ADD_STAT(simOps, Stats::units::Count::get(),
"Number of ops (including micro ops) simulated"),
ADD_STAT(hostInstRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Second>::get(),
ADD_STAT(hostInstRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
"Simulator instruction rate (inst/s)"),
ADD_STAT(hostOpRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Second>::get(),
ADD_STAT(hostOpRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Second>::get(),
"Simulator op (including micro ops) rate (op/s)")
{
simInsts

20
src/cpu/kvm/base.cc
View File

@@ -260,25 +260,25 @@ BaseKvmCPU::startupThread()
BaseKvmCPU::StatGroup::StatGroup(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(committedInsts, Stats::Units::Count::get(),
ADD_STAT(committedInsts, Stats::units::Count::get(),
"Number of instructions committed"),
ADD_STAT(numVMExits, Stats::Units::Count::get(),
ADD_STAT(numVMExits, Stats::units::Count::get(),
"total number of KVM exits"),
ADD_STAT(numVMHalfEntries, Stats::Units::Count::get(),
ADD_STAT(numVMHalfEntries, Stats::units::Count::get(),
"number of KVM entries to finalize pending operations"),
ADD_STAT(numExitSignal, Stats::Units::Count::get(),
ADD_STAT(numExitSignal, Stats::units::Count::get(),
"exits due to signal delivery"),
ADD_STAT(numMMIO, Stats::Units::Count::get(),
ADD_STAT(numMMIO, Stats::units::Count::get(),
"number of VM exits due to memory mapped IO"),
ADD_STAT(numCoalescedMMIO, Stats::Units::Count::get(),
ADD_STAT(numCoalescedMMIO, Stats::units::Count::get(),
"number of coalesced memory mapped IO requests"),
ADD_STAT(numIO, Stats::Units::Count::get(),
ADD_STAT(numIO, Stats::units::Count::get(),
"number of VM exits due to legacy IO"),
ADD_STAT(numHalt, Stats::Units::Count::get(),
ADD_STAT(numHalt, Stats::units::Count::get(),
"number of VM exits due to wait for interrupt instructions"),
ADD_STAT(numInterrupts, Stats::Units::Count::get(),
ADD_STAT(numInterrupts, Stats::units::Count::get(),
"number of interrupts delivered"),
ADD_STAT(numHypercalls, Stats::Units::Count::get(), "number of hypercalls")
ADD_STAT(numHypercalls, Stats::units::Count::get(), "number of hypercalls")
{
}

12
src/cpu/minor/fetch2.cc
View File

@@ -605,17 +605,17 @@ Fetch2::isDrained()
Fetch2::Fetch2Stats::Fetch2Stats(MinorCPU *cpu)
: Stats::Group(cpu, "fetch2"),
ADD_STAT(intInstructions, Stats::Units::Count::get(),
ADD_STAT(intInstructions, Stats::units::Count::get(),
"Number of integer instructions successfully decoded"),
ADD_STAT(fpInstructions, Stats::Units::Count::get(),
ADD_STAT(fpInstructions, Stats::units::Count::get(),
"Number of floating point instructions successfully decoded"),
ADD_STAT(vecInstructions, Stats::Units::Count::get(),
ADD_STAT(vecInstructions, Stats::units::Count::get(),
"Number of SIMD instructions successfully decoded"),
ADD_STAT(loadInstructions, Stats::Units::Count::get(),
ADD_STAT(loadInstructions, Stats::units::Count::get(),
"Number of memory load instructions successfully decoded"),
ADD_STAT(storeInstructions, Stats::Units::Count::get(),
ADD_STAT(storeInstructions, Stats::units::Count::get(),
"Number of memory store instructions successfully decoded"),
ADD_STAT(amoInstructions, Stats::Units::Count::get(),
ADD_STAT(amoInstructions, Stats::units::Count::get(),
"Number of memory atomic instructions successfully decoded")
{
intInstructions

20
src/cpu/minor/stats.cc
View File

@@ -42,25 +42,25 @@ namespace Minor
MinorStats::MinorStats(BaseCPU *base_cpu)
: Stats::Group(base_cpu),
ADD_STAT(numInsts, Stats::Units::Count::get(),
ADD_STAT(numInsts, Stats::units::Count::get(),
"Number of instructions committed"),
ADD_STAT(numOps, Stats::Units::Count::get(),
ADD_STAT(numOps, Stats::units::Count::get(),
"Number of ops (including micro ops) committed"),
ADD_STAT(numDiscardedOps, Stats::Units::Count::get(),
ADD_STAT(numDiscardedOps, Stats::units::Count::get(),
"Number of ops (including micro ops) which were discarded before "
"commit"),
ADD_STAT(numFetchSuspends, Stats::Units::Count::get(),
ADD_STAT(numFetchSuspends, Stats::units::Count::get(),
"Number of times Execute suspended instruction fetching"),
ADD_STAT(quiesceCycles, Stats::Units::Cycle::get(),
ADD_STAT(quiesceCycles, Stats::units::Cycle::get(),
"Total number of cycles that CPU has spent quiesced or waiting "
"for an interrupt"),
ADD_STAT(cpi, Stats::Units::Rate<
Stats::Units::Cycle, Stats::Units::Count>::get(),
ADD_STAT(cpi, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
"CPI: cycles per instruction"),
ADD_STAT(ipc, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(ipc, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"IPC: instructions per cycle"),
ADD_STAT(committedInstType, Stats::Units::Count::get(),
ADD_STAT(committedInstType, Stats::units::Count::get(),
"Class of committed instruction")
{
quiesceCycles.prereq(quiesceCycles);

34
src/cpu/o3/commit.cc
View File

@@ -145,39 +145,39 @@ Commit::regProbePoints()
Commit::CommitStats::CommitStats(CPU *cpu, Commit *commit)
: Stats::Group(cpu, "commit"),
ADD_STAT(commitSquashedInsts, Stats::Units::Count::get(),
ADD_STAT(commitSquashedInsts, Stats::units::Count::get(),
"The number of squashed insts skipped by commit"),
ADD_STAT(commitNonSpecStalls, Stats::Units::Count::get(),
ADD_STAT(commitNonSpecStalls, Stats::units::Count::get(),
"The number of times commit has been forced to stall to "
"communicate backwards"),
ADD_STAT(branchMispredicts, Stats::Units::Count::get(),
ADD_STAT(branchMispredicts, Stats::units::Count::get(),
"The number of times a branch was mispredicted"),
ADD_STAT(numCommittedDist, Stats::Units::Count::get(),
ADD_STAT(numCommittedDist, Stats::units::Count::get(),
"Number of insts commited each cycle"),
ADD_STAT(instsCommitted, Stats::Units::Count::get(),
ADD_STAT(instsCommitted, Stats::units::Count::get(),
"Number of instructions committed"),
ADD_STAT(opsCommitted, Stats::Units::Count::get(),
ADD_STAT(opsCommitted, Stats::units::Count::get(),
"Number of ops (including micro ops) committed"),
ADD_STAT(memRefs, Stats::Units::Count::get(),
ADD_STAT(memRefs, Stats::units::Count::get(),
"Number of memory references committed"),
ADD_STAT(loads, Stats::Units::Count::get(), "Number of loads committed"),
ADD_STAT(amos, Stats::Units::Count::get(),
ADD_STAT(loads, Stats::units::Count::get(), "Number of loads committed"),
ADD_STAT(amos, Stats::units::Count::get(),
"Number of atomic instructions committed"),
ADD_STAT(membars, Stats::Units::Count::get(),
ADD_STAT(membars, Stats::units::Count::get(),
"Number of memory barriers committed"),
ADD_STAT(branches, Stats::Units::Count::get(),
ADD_STAT(branches, Stats::units::Count::get(),
"Number of branches committed"),
ADD_STAT(vectorInstructions, Stats::Units::Count::get(),
ADD_STAT(vectorInstructions, Stats::units::Count::get(),
"Number of committed Vector instructions."),
ADD_STAT(floating, Stats::Units::Count::get(),
ADD_STAT(floating, Stats::units::Count::get(),
"Number of committed floating point instructions."),
ADD_STAT(integer, Stats::Units::Count::get(),
ADD_STAT(integer, Stats::units::Count::get(),
"Number of committed integer instructions."),
ADD_STAT(functionCalls, Stats::Units::Count::get(),
ADD_STAT(functionCalls, Stats::units::Count::get(),
"Number of function calls committed."),
ADD_STAT(committedInstType, Stats::Units::Count::get(),
ADD_STAT(committedInstType, Stats::units::Count::get(),
"Class of committed instruction"),
ADD_STAT(commitEligibleSamples, Stats::Units::Cycle::get(),
ADD_STAT(commitEligibleSamples, Stats::units::Cycle::get(),
"number cycles where commit BW limit reached")
{
using namespace Stats;

50
src/cpu/o3/cpu.cc
View File

@@ -372,54 +372,54 @@ CPU::regProbePoints()
CPU::CPUStats::CPUStats(CPU *cpu)
: Stats::Group(cpu),
ADD_STAT(timesIdled, Stats::Units::Count::get(),
ADD_STAT(timesIdled, Stats::units::Count::get(),
"Number of times that the entire CPU went into an idle state "
"and unscheduled itself"),
ADD_STAT(idleCycles, Stats::Units::Cycle::get(),
ADD_STAT(idleCycles, Stats::units::Cycle::get(),
"Total number of cycles that the CPU has spent unscheduled due "
"to idling"),
ADD_STAT(quiesceCycles, Stats::Units::Cycle::get(),
ADD_STAT(quiesceCycles, Stats::units::Cycle::get(),
"Total number of cycles that CPU has spent quiesced or waiting "
"for an interrupt"),
ADD_STAT(committedInsts, Stats::Units::Count::get(),
ADD_STAT(committedInsts, Stats::units::Count::get(),
"Number of Instructions Simulated"),
ADD_STAT(committedOps, Stats::Units::Count::get(),
ADD_STAT(committedOps, Stats::units::Count::get(),
"Number of Ops (including micro ops) Simulated"),
ADD_STAT(cpi, Stats::Units::Rate<
Stats::Units::Cycle, Stats::Units::Count>::get(),
ADD_STAT(cpi, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
"CPI: Cycles Per Instruction"),
ADD_STAT(totalCpi, Stats::Units::Rate<
Stats::Units::Cycle, Stats::Units::Count>::get(),
ADD_STAT(totalCpi, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
"CPI: Total CPI of All Threads"),
ADD_STAT(ipc, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(ipc, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"IPC: Instructions Per Cycle"),
ADD_STAT(totalIpc, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(totalIpc, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"IPC: Total IPC of All Threads"),
ADD_STAT(intRegfileReads, Stats::Units::Count::get(),
ADD_STAT(intRegfileReads, Stats::units::Count::get(),
"Number of integer regfile reads"),
ADD_STAT(intRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(intRegfileWrites, Stats::units::Count::get(),
"Number of integer regfile writes"),
ADD_STAT(fpRegfileReads, Stats::Units::Count::get(),
ADD_STAT(fpRegfileReads, Stats::units::Count::get(),
"Number of floating regfile reads"),
ADD_STAT(fpRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(fpRegfileWrites, Stats::units::Count::get(),
"Number of floating regfile writes"),
ADD_STAT(vecRegfileReads, Stats::Units::Count::get(),
ADD_STAT(vecRegfileReads, Stats::units::Count::get(),
"number of vector regfile reads"),
ADD_STAT(vecRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(vecRegfileWrites, Stats::units::Count::get(),
"number of vector regfile writes"),
ADD_STAT(vecPredRegfileReads, Stats::Units::Count::get(),
ADD_STAT(vecPredRegfileReads, Stats::units::Count::get(),
"number of predicate regfile reads"),
ADD_STAT(vecPredRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(vecPredRegfileWrites, Stats::units::Count::get(),
"number of predicate regfile writes"),
ADD_STAT(ccRegfileReads, Stats::Units::Count::get(),
ADD_STAT(ccRegfileReads, Stats::units::Count::get(),
"number of cc regfile reads"),
ADD_STAT(ccRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(ccRegfileWrites, Stats::units::Count::get(),
"number of cc regfile writes"),
ADD_STAT(miscRegfileReads, Stats::Units::Count::get(),
ADD_STAT(miscRegfileReads, Stats::units::Count::get(),
"number of misc regfile reads"),
ADD_STAT(miscRegfileWrites, Stats::Units::Count::get(),
ADD_STAT(miscRegfileWrites, Stats::units::Count::get(),
"number of misc regfile writes")
{
// Register any of the O3CPU's stats here.

20
src/cpu/o3/decode.cc
View File

@@ -119,26 +119,26 @@ Decode::name() const
Decode::DecodeStats::DecodeStats(CPU *cpu)
: Stats::Group(cpu, "decode"),
ADD_STAT(idleCycles, Stats::Units::Cycle::get(),
ADD_STAT(idleCycles, Stats::units::Cycle::get(),
"Number of cycles decode is idle"),
ADD_STAT(blockedCycles, Stats::Units::Cycle::get(),
ADD_STAT(blockedCycles, Stats::units::Cycle::get(),
"Number of cycles decode is blocked"),
ADD_STAT(runCycles, Stats::Units::Cycle::get(),
ADD_STAT(runCycles, Stats::units::Cycle::get(),
"Number of cycles decode is running"),
ADD_STAT(unblockCycles, Stats::Units::Cycle::get(),
ADD_STAT(unblockCycles, Stats::units::Cycle::get(),
"Number of cycles decode is unblocking"),
ADD_STAT(squashCycles, Stats::Units::Cycle::get(),
ADD_STAT(squashCycles, Stats::units::Cycle::get(),
"Number of cycles decode is squashing"),
ADD_STAT(branchResolved, Stats::Units::Count::get(),
ADD_STAT(branchResolved, Stats::units::Count::get(),
"Number of times decode resolved a branch"),
ADD_STAT(branchMispred, Stats::Units::Count::get(),
ADD_STAT(branchMispred, Stats::units::Count::get(),
"Number of times decode detected a branch misprediction"),
ADD_STAT(controlMispred, Stats::Units::Count::get(),
ADD_STAT(controlMispred, Stats::units::Count::get(),
"Number of times decode detected an instruction incorrectly "
"predicted as a control"),
ADD_STAT(decodedInsts, Stats::Units::Count::get(),
ADD_STAT(decodedInsts, Stats::units::Count::get(),
"Number of instructions handled by decode"),
ADD_STAT(squashedInsts, Stats::Units::Count::get(),
ADD_STAT(squashedInsts, Stats::units::Count::get(),
"Number of squashed instructions handled by decode")
{
idleCycles.prereq(idleCycles);

46
src/cpu/o3/fetch.cc
View File

@@ -157,54 +157,54 @@ Fetch::regProbePoints()
Fetch::FetchStatGroup::FetchStatGroup(CPU *cpu, Fetch *fetch)
: Stats::Group(cpu, "fetch"),
ADD_STAT(icacheStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(icacheStallCycles, Stats::units::Cycle::get(),
"Number of cycles fetch is stalled on an Icache miss"),
ADD_STAT(insts, Stats::Units::Count::get(),
ADD_STAT(insts, Stats::units::Count::get(),
"Number of instructions fetch has processed"),
ADD_STAT(branches, Stats::Units::Count::get(),
ADD_STAT(branches, Stats::units::Count::get(),
"Number of branches that fetch encountered"),
ADD_STAT(predictedBranches, Stats::Units::Count::get(),
ADD_STAT(predictedBranches, Stats::units::Count::get(),
"Number of branches that fetch has predicted taken"),
ADD_STAT(cycles, Stats::Units::Cycle::get(),
ADD_STAT(cycles, Stats::units::Cycle::get(),
"Number of cycles fetch has run and was not squashing or "
"blocked"),
ADD_STAT(squashCycles, Stats::Units::Cycle::get(),
ADD_STAT(squashCycles, Stats::units::Cycle::get(),
"Number of cycles fetch has spent squashing"),
ADD_STAT(tlbCycles, Stats::Units::Cycle::get(),
ADD_STAT(tlbCycles, Stats::units::Cycle::get(),
"Number of cycles fetch has spent waiting for tlb"),
ADD_STAT(idleCycles, Stats::Units::Cycle::get(),
ADD_STAT(idleCycles, Stats::units::Cycle::get(),
"Number of cycles fetch was idle"),
ADD_STAT(blockedCycles, Stats::Units::Cycle::get(),
ADD_STAT(blockedCycles, Stats::units::Cycle::get(),
"Number of cycles fetch has spent blocked"),
ADD_STAT(miscStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(miscStallCycles, Stats::units::Cycle::get(),
"Number of cycles fetch has spent waiting on interrupts, or bad "
"addresses, or out of MSHRs"),
ADD_STAT(pendingDrainCycles, Stats::Units::Cycle::get(),
ADD_STAT(pendingDrainCycles, Stats::units::Cycle::get(),
"Number of cycles fetch has spent waiting on pipes to drain"),
ADD_STAT(noActiveThreadStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(noActiveThreadStallCycles, Stats::units::Cycle::get(),
"Number of stall cycles due to no active thread to fetch from"),
ADD_STAT(pendingTrapStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(pendingTrapStallCycles, Stats::units::Cycle::get(),
"Number of stall cycles due to pending traps"),
ADD_STAT(pendingQuiesceStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(pendingQuiesceStallCycles, Stats::units::Cycle::get(),
"Number of stall cycles due to pending quiesce instructions"),
ADD_STAT(icacheWaitRetryStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(icacheWaitRetryStallCycles, Stats::units::Cycle::get(),
"Number of stall cycles due to full MSHR"),
ADD_STAT(cacheLines, Stats::Units::Count::get(),
ADD_STAT(cacheLines, Stats::units::Count::get(),
"Number of cache lines fetched"),
ADD_STAT(icacheSquashes, Stats::Units::Count::get(),
ADD_STAT(icacheSquashes, Stats::units::Count::get(),
"Number of outstanding Icache misses that were squashed"),
ADD_STAT(tlbSquashes, Stats::Units::Count::get(),
ADD_STAT(tlbSquashes, Stats::units::Count::get(),
"Number of outstanding ITLB misses that were squashed"),
ADD_STAT(nisnDist, Stats::Units::Count::get(),
ADD_STAT(nisnDist, Stats::units::Count::get(),
"Number of instructions fetched each cycle (Total)"),
ADD_STAT(idleRate, Stats::Units::Ratio::get(),
ADD_STAT(idleRate, Stats::units::Ratio::get(),
"Ratio of cycles fetch was idle",
idleCycles / cpu->baseStats.numCycles),
ADD_STAT(branchRate, Stats::Units::Ratio::get(),
ADD_STAT(branchRate, Stats::units::Ratio::get(),
"Number of branch fetches per cycle",
branches / cpu->baseStats.numCycles),
ADD_STAT(rate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(rate, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"Number of inst fetches per cycle",
insts / cpu->baseStats.numCycles)
{

66
src/cpu/o3/iew.cc
View File

@@ -141,51 +141,51 @@ IEW::regProbePoints()
IEW::IEWStats::IEWStats(CPU *cpu)
: Stats::Group(cpu),
ADD_STAT(idleCycles, Stats::Units::Cycle::get(),
ADD_STAT(idleCycles, Stats::units::Cycle::get(),
"Number of cycles IEW is idle"),
ADD_STAT(squashCycles, Stats::Units::Cycle::get(),
ADD_STAT(squashCycles, Stats::units::Cycle::get(),
"Number of cycles IEW is squashing"),
ADD_STAT(blockCycles, Stats::Units::Cycle::get(),
ADD_STAT(blockCycles, Stats::units::Cycle::get(),
"Number of cycles IEW is blocking"),
ADD_STAT(unblockCycles, Stats::Units::Cycle::get(),
ADD_STAT(unblockCycles, Stats::units::Cycle::get(),
"Number of cycles IEW is unblocking"),
ADD_STAT(dispatchedInsts, Stats::Units::Count::get(),
ADD_STAT(dispatchedInsts, Stats::units::Count::get(),
"Number of instructions dispatched to IQ"),
ADD_STAT(dispSquashedInsts, Stats::Units::Count::get(),
ADD_STAT(dispSquashedInsts, Stats::units::Count::get(),
"Number of squashed instructions skipped by dispatch"),
ADD_STAT(dispLoadInsts, Stats::Units::Count::get(),
ADD_STAT(dispLoadInsts, Stats::units::Count::get(),
"Number of dispatched load instructions"),
ADD_STAT(dispStoreInsts, Stats::Units::Count::get(),
ADD_STAT(dispStoreInsts, Stats::units::Count::get(),
"Number of dispatched store instructions"),
ADD_STAT(dispNonSpecInsts, Stats::Units::Count::get(),
ADD_STAT(dispNonSpecInsts, Stats::units::Count::get(),
"Number of dispatched non-speculative instructions"),
ADD_STAT(iqFullEvents, Stats::Units::Count::get(),
ADD_STAT(iqFullEvents, Stats::units::Count::get(),
"Number of times the IQ has become full, causing a stall"),
ADD_STAT(lsqFullEvents, Stats::Units::Count::get(),
ADD_STAT(lsqFullEvents, Stats::units::Count::get(),
"Number of times the LSQ has become full, causing a stall"),
ADD_STAT(memOrderViolationEvents, Stats::Units::Count::get(),
ADD_STAT(memOrderViolationEvents, Stats::units::Count::get(),
"Number of memory order violations"),
ADD_STAT(predictedTakenIncorrect, Stats::Units::Count::get(),
ADD_STAT(predictedTakenIncorrect, Stats::units::Count::get(),
"Number of branches that were predicted taken incorrectly"),
ADD_STAT(predictedNotTakenIncorrect, Stats::Units::Count::get(),
ADD_STAT(predictedNotTakenIncorrect, Stats::units::Count::get(),
"Number of branches that were predicted not taken incorrectly"),
ADD_STAT(branchMispredicts, Stats::Units::Count::get(),
ADD_STAT(branchMispredicts, Stats::units::Count::get(),
"Number of branch mispredicts detected at execute",
predictedTakenIncorrect + predictedNotTakenIncorrect),
executedInstStats(cpu),
ADD_STAT(instsToCommit, Stats::Units::Count::get(),
ADD_STAT(instsToCommit, Stats::units::Count::get(),
"Cumulative count of insts sent to commit"),
ADD_STAT(writebackCount, Stats::Units::Count::get(),
ADD_STAT(writebackCount, Stats::units::Count::get(),
"Cumulative count of insts written-back"),
ADD_STAT(producerInst, Stats::Units::Count::get(),
ADD_STAT(producerInst, Stats::units::Count::get(),
"Number of instructions producing a value"),
ADD_STAT(consumerInst, Stats::Units::Count::get(),
ADD_STAT(consumerInst, Stats::units::Count::get(),
"Number of instructions consuming a value"),
ADD_STAT(wbRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(wbRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"Insts written-back per cycle"),
ADD_STAT(wbFanout, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Count>::get(),
ADD_STAT(wbFanout, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
"Average fanout of values written-back")
{
instsToCommit
@@ -215,24 +215,24 @@ IEW::IEWStats::IEWStats(CPU *cpu)
IEW::IEWStats::ExecutedInstStats::ExecutedInstStats(CPU *cpu)
: Stats::Group(cpu),
ADD_STAT(numInsts, Stats::Units::Count::get(),
ADD_STAT(numInsts, Stats::units::Count::get(),
"Number of executed instructions"),
ADD_STAT(numLoadInsts, Stats::Units::Count::get(),
ADD_STAT(numLoadInsts, Stats::units::Count::get(),
"Number of load instructions executed"),
ADD_STAT(numSquashedInsts, Stats::Units::Count::get(),
ADD_STAT(numSquashedInsts, Stats::units::Count::get(),
"Number of squashed instructions skipped in execute"),
ADD_STAT(numSwp, Stats::Units::Count::get(),
ADD_STAT(numSwp, Stats::units::Count::get(),
"Number of swp insts executed"),
ADD_STAT(numNop, Stats::Units::Count::get(),
ADD_STAT(numNop, Stats::units::Count::get(),
"Number of nop insts executed"),
ADD_STAT(numRefs, Stats::Units::Count::get(),
ADD_STAT(numRefs, Stats::units::Count::get(),
"Number of memory reference insts executed"),
ADD_STAT(numBranches, Stats::Units::Count::get(),
ADD_STAT(numBranches, Stats::units::Count::get(),
"Number of branches executed"),
ADD_STAT(numStoreInsts, Stats::Units::Count::get(),
ADD_STAT(numStoreInsts, Stats::units::Count::get(),
"Number of stores executed"),
ADD_STAT(numRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(numRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"Inst execution rate", numInsts / cpu->baseStats.numCycles)
{
numLoadInsts

64
src/cpu/o3/inst_queue.cc
View File

@@ -172,44 +172,44 @@ InstructionQueue::name() const
InstructionQueue::IQStats::IQStats(CPU *cpu, const unsigned &total_width)
: Stats::Group(cpu),
ADD_STAT(instsAdded, Stats::Units::Count::get(),
ADD_STAT(instsAdded, Stats::units::Count::get(),
"Number of instructions added to the IQ (excludes non-spec)"),
ADD_STAT(nonSpecInstsAdded, Stats::Units::Count::get(),
ADD_STAT(nonSpecInstsAdded, Stats::units::Count::get(),
"Number of non-speculative instructions added to the IQ"),
ADD_STAT(instsIssued, Stats::Units::Count::get(),
ADD_STAT(instsIssued, Stats::units::Count::get(),
"Number of instructions issued"),
ADD_STAT(intInstsIssued, Stats::Units::Count::get(),
ADD_STAT(intInstsIssued, Stats::units::Count::get(),
"Number of integer instructions issued"),
ADD_STAT(floatInstsIssued, Stats::Units::Count::get(),
ADD_STAT(floatInstsIssued, Stats::units::Count::get(),
"Number of float instructions issued"),
ADD_STAT(branchInstsIssued, Stats::Units::Count::get(),
ADD_STAT(branchInstsIssued, Stats::units::Count::get(),
"Number of branch instructions issued"),
ADD_STAT(memInstsIssued, Stats::Units::Count::get(),
ADD_STAT(memInstsIssued, Stats::units::Count::get(),
"Number of memory instructions issued"),
ADD_STAT(miscInstsIssued, Stats::Units::Count::get(),
ADD_STAT(miscInstsIssued, Stats::units::Count::get(),
"Number of miscellaneous instructions issued"),
ADD_STAT(squashedInstsIssued, Stats::Units::Count::get(),
ADD_STAT(squashedInstsIssued, Stats::units::Count::get(),
"Number of squashed instructions issued"),
ADD_STAT(squashedInstsExamined, Stats::Units::Count::get(),
ADD_STAT(squashedInstsExamined, Stats::units::Count::get(),
"Number of squashed instructions iterated over during squash; "
"mainly for profiling"),
ADD_STAT(squashedOperandsExamined, Stats::Units::Count::get(),
ADD_STAT(squashedOperandsExamined, Stats::units::Count::get(),
"Number of squashed operands that are examined and possibly "
"removed from graph"),
ADD_STAT(squashedNonSpecRemoved, Stats::Units::Count::get(),
ADD_STAT(squashedNonSpecRemoved, Stats::units::Count::get(),
"Number of squashed non-spec instructions that were removed"),
ADD_STAT(numIssuedDist, Stats::Units::Count::get(),
ADD_STAT(numIssuedDist, Stats::units::Count::get(),
"Number of insts issued each cycle"),
ADD_STAT(statFuBusy, Stats::Units::Count::get(),
ADD_STAT(statFuBusy, Stats::units::Count::get(),
"attempts to use FU when none available"),
ADD_STAT(statIssuedInstType, Stats::Units::Count::get(),
ADD_STAT(statIssuedInstType, Stats::units::Count::get(),
"Number of instructions issued per FU type, per thread"),
ADD_STAT(issueRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Cycle>::get(),
ADD_STAT(issueRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Cycle>::get(),
"Inst issue rate", instsIssued / cpu->baseStats.numCycles),
ADD_STAT(fuBusy, Stats::Units::Count::get(), "FU busy when requested"),
ADD_STAT(fuBusyRate, Stats::Units::Rate<
Stats::Units::Count, Stats::Units::Count>::get(),
ADD_STAT(fuBusy, Stats::units::Count::get(), "FU busy when requested"),
ADD_STAT(fuBusyRate, Stats::units::Rate<
Stats::units::Count, Stats::units::Count>::get(),
"FU busy rate (busy events/executed inst)")
{
instsAdded
@@ -320,29 +320,29 @@ InstructionQueue::IQStats::IQStats(CPU *cpu, const unsigned &total_width)
InstructionQueue::IQIOStats::IQIOStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(intInstQueueReads, Stats::Units::Count::get(),
ADD_STAT(intInstQueueReads, Stats::units::Count::get(),
"Number of integer instruction queue reads"),
ADD_STAT(intInstQueueWrites, Stats::Units::Count::get(),
ADD_STAT(intInstQueueWrites, Stats::units::Count::get(),
"Number of integer instruction queue writes"),
ADD_STAT(intInstQueueWakeupAccesses, Stats::Units::Count::get(),
ADD_STAT(intInstQueueWakeupAccesses, Stats::units::Count::get(),
"Number of integer instruction queue wakeup accesses"),
ADD_STAT(fpInstQueueReads, Stats::Units::Count::get(),
ADD_STAT(fpInstQueueReads, Stats::units::Count::get(),
"Number of floating instruction queue reads"),
ADD_STAT(fpInstQueueWrites, Stats::Units::Count::get(),
ADD_STAT(fpInstQueueWrites, Stats::units::Count::get(),
"Number of floating instruction queue writes"),
ADD_STAT(fpInstQueueWakeupAccesses, Stats::Units::Count::get(),
ADD_STAT(fpInstQueueWakeupAccesses, Stats::units::Count::get(),
"Number of floating instruction queue wakeup accesses"),
ADD_STAT(vecInstQueueReads, Stats::Units::Count::get(),
ADD_STAT(vecInstQueueReads, Stats::units::Count::get(),
"Number of vector instruction queue reads"),
ADD_STAT(vecInstQueueWrites, Stats::Units::Count::get(),
ADD_STAT(vecInstQueueWrites, Stats::units::Count::get(),
"Number of vector instruction queue writes"),
ADD_STAT(vecInstQueueWakeupAccesses, Stats::Units::Count::get(),
ADD_STAT(vecInstQueueWakeupAccesses, Stats::units::Count::get(),
"Number of vector instruction queue wakeup accesses"),
ADD_STAT(intAluAccesses, Stats::Units::Count::get(),
ADD_STAT(intAluAccesses, Stats::units::Count::get(),
"Number of integer alu accesses"),
ADD_STAT(fpAluAccesses, Stats::Units::Count::get(),
ADD_STAT(fpAluAccesses, Stats::units::Count::get(),
"Number of floating point alu accesses"),
ADD_STAT(vecAluAccesses, Stats::Units::Count::get(),
ADD_STAT(vecAluAccesses, Stats::units::Count::get(),
"Number of vector alu accesses")
{
using namespace Stats;

14
src/cpu/o3/lsq_unit.cc
View File

@@ -260,20 +260,20 @@ LSQUnit::name() const
LSQUnit::LSQUnitStats::LSQUnitStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(forwLoads, Stats::Units::Count::get(),
ADD_STAT(forwLoads, Stats::units::Count::get(),
"Number of loads that had data forwarded from stores"),
ADD_STAT(squashedLoads, Stats::Units::Count::get(),
ADD_STAT(squashedLoads, Stats::units::Count::get(),
"Number of loads squashed"),
ADD_STAT(ignoredResponses, Stats::Units::Count::get(),
ADD_STAT(ignoredResponses, Stats::units::Count::get(),
"Number of memory responses ignored because the instruction is "
"squashed"),
ADD_STAT(memOrderViolation, Stats::Units::Count::get(),
ADD_STAT(memOrderViolation, Stats::units::Count::get(),
"Number of memory ordering violations"),
ADD_STAT(squashedStores, Stats::Units::Count::get(),
ADD_STAT(squashedStores, Stats::units::Count::get(),
"Number of stores squashed"),
ADD_STAT(rescheduledLoads, Stats::Units::Count::get(),
ADD_STAT(rescheduledLoads, Stats::units::Count::get(),
"Number of loads that were rescheduled"),
ADD_STAT(blockedByCache, Stats::Units::Count::get(),
ADD_STAT(blockedByCache, Stats::units::Count::get(),
"Number of times an access to memory failed due to the cache "
"being blocked")
{

8
src/cpu/o3/mem_dep_unit.cc
View File

@@ -102,13 +102,13 @@ MemDepUnit::init(const O3CPUParams &params, ThreadID tid, CPU *cpu)
MemDepUnit::MemDepUnitStats::MemDepUnitStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(insertedLoads, Stats::Units::Count::get(),
ADD_STAT(insertedLoads, Stats::units::Count::get(),
"Number of loads inserted to the mem dependence unit."),
ADD_STAT(insertedStores, Stats::Units::Count::get(),
ADD_STAT(insertedStores, Stats::units::Count::get(),
"Number of stores inserted to the mem dependence unit."),
ADD_STAT(conflictingLoads, Stats::Units::Count::get(),
ADD_STAT(conflictingLoads, Stats::units::Count::get(),
"Number of conflicting loads."),
ADD_STAT(conflictingStores, Stats::Units::Count::get(),
ADD_STAT(conflictingStores, Stats::units::Count::get(),
"Number of conflicting stores.")
{
}

18
src/cpu/o3/probe/elastic_trace.cc
View File

@@ -886,27 +886,27 @@ ElasticTrace::writeDepTrace(uint32_t num_to_write)
ElasticTrace::ElasticTraceStats::ElasticTraceStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(numRegDep, Stats::Units::Count::get(),
ADD_STAT(numRegDep, Stats::units::Count::get(),
"Number of register dependencies recorded during tracing"),
ADD_STAT(numOrderDepStores, Stats::Units::Count::get(),
ADD_STAT(numOrderDepStores, Stats::units::Count::get(),
"Number of commit order (rob) dependencies for a store "
"recorded on a past load/store during tracing"),
ADD_STAT(numIssueOrderDepLoads, Stats::Units::Count::get(),
ADD_STAT(numIssueOrderDepLoads, Stats::units::Count::get(),
"Number of loads that got assigned issue order dependency "
"because they were dependency-free"),
ADD_STAT(numIssueOrderDepStores, Stats::Units::Count::get(),
ADD_STAT(numIssueOrderDepStores, Stats::units::Count::get(),
"Number of stores that got assigned issue order dependency "
"because they were dependency-free"),
ADD_STAT(numIssueOrderDepOther, Stats::Units::Count::get(),
ADD_STAT(numIssueOrderDepOther, Stats::units::Count::get(),
"Number of non load/store insts that got assigned issue order "
"dependency because they were dependency-free"),
ADD_STAT(numFilteredNodes, Stats::Units::Count::get(),
ADD_STAT(numFilteredNodes, Stats::units::Count::get(),
"No. of nodes filtered out before writing the output trace"),
ADD_STAT(maxNumDependents, Stats::Units::Count::get(),
ADD_STAT(maxNumDependents, Stats::units::Count::get(),
"Maximum number or dependents on any instruction"),
ADD_STAT(maxTempStoreSize, Stats::Units::Count::get(),
ADD_STAT(maxTempStoreSize, Stats::units::Count::get(),
"Maximum size of the temporary store during the run"),
ADD_STAT(maxPhysRegDepMapSize, Stats::Units::Count::get(),
ADD_STAT(maxPhysRegDepMapSize, Stats::units::Count::get(),
"Maximum size of register dependency map")
{
}

48
src/cpu/o3/rename.cc
View File

@@ -93,53 +93,53 @@ Rename::name() const
Rename::RenameStats::RenameStats(Stats::Group *parent)
: Stats::Group(parent, "rename"),
ADD_STAT(squashCycles, Stats::Units::Cycle::get(),
ADD_STAT(squashCycles, Stats::units::Cycle::get(),
"Number of cycles rename is squashing"),
ADD_STAT(idleCycles, Stats::Units::Cycle::get(),
ADD_STAT(idleCycles, Stats::units::Cycle::get(),
"Number of cycles rename is idle"),
ADD_STAT(blockCycles, Stats::Units::Cycle::get(),
ADD_STAT(blockCycles, Stats::units::Cycle::get(),
"Number of cycles rename is blocking"),
ADD_STAT(serializeStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(serializeStallCycles, Stats::units::Cycle::get(),
"count of cycles rename stalled for serializing inst"),
ADD_STAT(runCycles, Stats::Units::Cycle::get(),
ADD_STAT(runCycles, Stats::units::Cycle::get(),
"Number of cycles rename is running"),
ADD_STAT(unblockCycles, Stats::Units::Cycle::get(),
ADD_STAT(unblockCycles, Stats::units::Cycle::get(),
"Number of cycles rename is unblocking"),
ADD_STAT(renamedInsts, Stats::Units::Count::get(),
ADD_STAT(renamedInsts, Stats::units::Count::get(),
"Number of instructions processed by rename"),
ADD_STAT(squashedInsts, Stats::Units::Count::get(),
ADD_STAT(squashedInsts, Stats::units::Count::get(),
"Number of squashed instructions processed by rename"),
ADD_STAT(ROBFullEvents, Stats::Units::Count::get(),
ADD_STAT(ROBFullEvents, Stats::units::Count::get(),
"Number of times rename has blocked due to ROB full"),
ADD_STAT(IQFullEvents, Stats::Units::Count::get(),
ADD_STAT(IQFullEvents, Stats::units::Count::get(),
"Number of times rename has blocked due to IQ full"),
ADD_STAT(LQFullEvents, Stats::Units::Count::get(),
ADD_STAT(LQFullEvents, Stats::units::Count::get(),
"Number of times rename has blocked due to LQ full" ),
ADD_STAT(SQFullEvents, Stats::Units::Count::get(),
ADD_STAT(SQFullEvents, Stats::units::Count::get(),
"Number of times rename has blocked due to SQ full"),
ADD_STAT(fullRegistersEvents, Stats::Units::Count::get(),
ADD_STAT(fullRegistersEvents, Stats::units::Count::get(),
"Number of times there has been no free registers"),
ADD_STAT(renamedOperands, Stats::Units::Count::get(),
ADD_STAT(renamedOperands, Stats::units::Count::get(),
"Number of destination operands rename has renamed"),
ADD_STAT(lookups, Stats::Units::Count::get(),
ADD_STAT(lookups, Stats::units::Count::get(),
"Number of register rename lookups that rename has made"),
ADD_STAT(intLookups, Stats::Units::Count::get(),
ADD_STAT(intLookups, Stats::units::Count::get(),
"Number of integer rename lookups"),
ADD_STAT(fpLookups, Stats::Units::Count::get(),
ADD_STAT(fpLookups, Stats::units::Count::get(),
"Number of floating rename lookups"),
ADD_STAT(vecLookups, Stats::Units::Count::get(),
ADD_STAT(vecLookups, Stats::units::Count::get(),
"Number of vector rename lookups"),
ADD_STAT(vecPredLookups, Stats::Units::Count::get(),
ADD_STAT(vecPredLookups, Stats::units::Count::get(),
"Number of vector predicate rename lookups"),
ADD_STAT(committedMaps, Stats::Units::Count::get(),
ADD_STAT(committedMaps, Stats::units::Count::get(),
"Number of HB maps that are committed"),
ADD_STAT(undoneMaps, Stats::Units::Count::get(),
ADD_STAT(undoneMaps, Stats::units::Count::get(),
"Number of HB maps that are undone due to squashing"),
ADD_STAT(serializing, Stats::Units::Count::get(),
ADD_STAT(serializing, Stats::units::Count::get(),
"count of serializing insts renamed"),
ADD_STAT(tempSerializing, Stats::Units::Count::get(),
ADD_STAT(tempSerializing, Stats::units::Count::get(),
"count of temporary serializing insts renamed"),
ADD_STAT(skidInsts, Stats::Units::Count::get(),
ADD_STAT(skidInsts, Stats::units::Count::get(),
"count of insts added to the skid buffer")
{
squashCycles.prereq(squashCycles);

4
src/cpu/o3/rob.cc
View File

@@ -520,8 +520,8 @@ ROB::readTailInst(ThreadID tid)
ROB::ROBStats::ROBStats(Stats::Group *parent)
: Stats::Group(parent, "rob"),
ADD_STAT(reads, Stats::Units::Count::get(), "The number of ROB reads"),
ADD_STAT(writes, Stats::Units::Count::get(), "The number of ROB writes")
ADD_STAT(reads, Stats::units::Count::get(), "The number of ROB reads"),
ADD_STAT(writes, Stats::units::Count::get(), "The number of ROB writes")
{
}

24
src/cpu/pred/bpred_unit.cc
View File

@@ -69,27 +69,27 @@ BPredUnit::BPredUnit(const Params &params)
BPredUnit::BPredUnitStats::BPredUnitStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(lookups, Stats::Units::Count::get(), "Number of BP lookups"),
ADD_STAT(condPredicted, Stats::Units::Count::get(),
ADD_STAT(lookups, Stats::units::Count::get(), "Number of BP lookups"),
ADD_STAT(condPredicted, Stats::units::Count::get(),
"Number of conditional branches predicted"),
ADD_STAT(condIncorrect, Stats::Units::Count::get(),
ADD_STAT(condIncorrect, Stats::units::Count::get(),
"Number of conditional branches incorrect"),
ADD_STAT(BTBLookups, Stats::Units::Count::get(),
ADD_STAT(BTBLookups, Stats::units::Count::get(),
"Number of BTB lookups"),
ADD_STAT(BTBHits, Stats::Units::Count::get(), "Number of BTB hits"),
ADD_STAT(BTBHitRatio, Stats::Units::Ratio::get(), "BTB Hit Ratio",
ADD_STAT(BTBHits, Stats::units::Count::get(), "Number of BTB hits"),
ADD_STAT(BTBHitRatio, Stats::units::Ratio::get(), "BTB Hit Ratio",
BTBHits / BTBLookups),
ADD_STAT(RASUsed, Stats::Units::Count::get(),
ADD_STAT(RASUsed, Stats::units::Count::get(),
"Number of times the RAS was used to get a target."),
ADD_STAT(RASIncorrect, Stats::Units::Count::get(),
ADD_STAT(RASIncorrect, Stats::units::Count::get(),
"Number of incorrect RAS predictions."),
ADD_STAT(indirectLookups, Stats::Units::Count::get(),
ADD_STAT(indirectLookups, Stats::units::Count::get(),
"Number of indirect predictor lookups."),
ADD_STAT(indirectHits, Stats::Units::Count::get(),
ADD_STAT(indirectHits, Stats::units::Count::get(),
"Number of indirect target hits."),
ADD_STAT(indirectMisses, Stats::Units::Count::get(),
ADD_STAT(indirectMisses, Stats::units::Count::get(),
"Number of indirect misses."),
ADD_STAT(indirectMispredicted, Stats::Units::Count::get(),
ADD_STAT(indirectMispredicted, Stats::units::Count::get(),
"Number of mispredicted indirect branches.")
{
BTBHitRatio.precision(6);

4
src/cpu/pred/loop_predictor.cc
View File

@@ -347,10 +347,10 @@ LoopPredictor::condBranchUpdate(ThreadID tid, Addr branch_pc, bool taken,
LoopPredictor::LoopPredictorStats::LoopPredictorStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(correct, Stats::Units::Count::get(),
ADD_STAT(correct, Stats::units::Count::get(),
"Number of times the loop predictor is the provider and the "
"prediction is correct"),
ADD_STAT(wrong, Stats::Units::Count::get(),
ADD_STAT(wrong, Stats::units::Count::get(),
"Number of times the loop predictor is the provider and the "
"prediction is wrong")
{

4
src/cpu/pred/statistical_corrector.cc
View File

@@ -400,10 +400,10 @@ StatisticalCorrector::getSizeInBits() const
StatisticalCorrector::StatisticalCorrectorStats::StatisticalCorrectorStats(
Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(correct, Stats::Units::Count::get(),
ADD_STAT(correct, Stats::units::Count::get(),
"Number of time the SC predictor is the provider and the "
"prediction is correct"),
ADD_STAT(wrong, Stats::Units::Count::get(),
ADD_STAT(wrong, Stats::units::Count::get(),
"Number of time the SC predictor is the provider and the "
"prediction is wrong")
{

24
src/cpu/pred/tage_base.cc
View File

@@ -719,39 +719,39 @@ TAGEBase::getGHR(ThreadID tid, BranchInfo *bi) const
TAGEBase::TAGEBaseStats::TAGEBaseStats(
Stats::Group *parent, unsigned nHistoryTables)
: Stats::Group(parent),
ADD_STAT(longestMatchProviderCorrect, Stats::Units::Count::get(),
ADD_STAT(longestMatchProviderCorrect, Stats::units::Count::get(),
"Number of times TAGE Longest Match is the provider and the "
"prediction is correct"),
ADD_STAT(altMatchProviderCorrect, Stats::Units::Count::get(),
ADD_STAT(altMatchProviderCorrect, Stats::units::Count::get(),
"Number of times TAGE Alt Match is the provider and the "
"prediction is correct"),
ADD_STAT(bimodalAltMatchProviderCorrect, Stats::Units::Count::get(),
ADD_STAT(bimodalAltMatchProviderCorrect, Stats::units::Count::get(),
"Number of times TAGE Alt Match is the bimodal and it is the "
"provider and the prediction is correct"),
ADD_STAT(bimodalProviderCorrect, Stats::Units::Count::get(),
ADD_STAT(bimodalProviderCorrect, Stats::units::Count::get(),
"Number of times there are no hits on the TAGE tables and the "
"bimodal prediction is correct"),
ADD_STAT(longestMatchProviderWrong, Stats::Units::Count::get(),
ADD_STAT(longestMatchProviderWrong, Stats::units::Count::get(),
"Number of times TAGE Longest Match is the provider and the "
"prediction is wrong"),
ADD_STAT(altMatchProviderWrong, Stats::Units::Count::get(),
ADD_STAT(altMatchProviderWrong, Stats::units::Count::get(),
"Number of times TAGE Alt Match is the provider and the "
"prediction is wrong"),
ADD_STAT(bimodalAltMatchProviderWrong, Stats::Units::Count::get(),
ADD_STAT(bimodalAltMatchProviderWrong, Stats::units::Count::get(),
"Number of times TAGE Alt Match is the bimodal and it is the "
"provider and the prediction is wrong"),
ADD_STAT(bimodalProviderWrong, Stats::Units::Count::get(),
ADD_STAT(bimodalProviderWrong, Stats::units::Count::get(),
"Number of times there are no hits on the TAGE tables and the "
"bimodal prediction is wrong"),
ADD_STAT(altMatchProviderWouldHaveHit, Stats::Units::Count::get(),
ADD_STAT(altMatchProviderWouldHaveHit, Stats::units::Count::get(),
"Number of times TAGE Longest Match is the provider, the "
"prediction is wrong and Alt Match prediction was correct"),
ADD_STAT(longestMatchProviderWouldHaveHit, Stats::Units::Count::get(),
ADD_STAT(longestMatchProviderWouldHaveHit, Stats::units::Count::get(),
"Number of times TAGE Alt Match is the provider, the "
"prediction is wrong and Longest Match prediction was correct"),
ADD_STAT(longestMatchProvider, Stats::Units::Count::get(),
ADD_STAT(longestMatchProvider, Stats::units::Count::get(),
"TAGE provider for longest match"),
ADD_STAT(altMatchProvider, Stats::Units::Count::get(),
ADD_STAT(altMatchProvider, Stats::units::Count::get(),
"TAGE provider for alt match")
{
longestMatchProvider.init(nHistoryTables + 1);

66
src/cpu/simple/exec_context.hh
View File

@@ -85,71 +85,71 @@ class SimpleExecContext : public ExecContext
: Stats::Group(cpu,
csprintf("exec_context.thread_%i",
thread->threadId()).c_str()),
ADD_STAT(numInsts, Stats::Units::Count::get(),
ADD_STAT(numInsts, Stats::units::Count::get(),
"Number of instructions committed"),
ADD_STAT(numOps, Stats::Units::Count::get(),
ADD_STAT(numOps, Stats::units::Count::get(),
"Number of ops (including micro ops) committed"),
ADD_STAT(numIntAluAccesses, Stats::Units::Count::get(),
ADD_STAT(numIntAluAccesses, Stats::units::Count::get(),
"Number of integer alu accesses"),
ADD_STAT(numFpAluAccesses, Stats::Units::Count::get(),
ADD_STAT(numFpAluAccesses, Stats::units::Count::get(),
"Number of float alu accesses"),
ADD_STAT(numVecAluAccesses, Stats::Units::Count::get(),
ADD_STAT(numVecAluAccesses, Stats::units::Count::get(),
"Number of vector alu accesses"),
ADD_STAT(numCallsReturns, Stats::Units::Count::get(),
ADD_STAT(numCallsReturns, Stats::units::Count::get(),
"Number of times a function call or return occured"),
ADD_STAT(numCondCtrlInsts, Stats::Units::Count::get(),
ADD_STAT(numCondCtrlInsts, Stats::units::Count::get(),
"Number of instructions that are conditional controls"),
ADD_STAT(numIntInsts, Stats::Units::Count::get(),
ADD_STAT(numIntInsts, Stats::units::Count::get(),
"Number of integer instructions"),
ADD_STAT(numFpInsts, Stats::Units::Count::get(),
ADD_STAT(numFpInsts, Stats::units::Count::get(),
"Number of float instructions"),
ADD_STAT(numVecInsts, Stats::Units::Count::get(),
ADD_STAT(numVecInsts, Stats::units::Count::get(),
"Number of vector instructions"),
ADD_STAT(numIntRegReads, Stats::Units::Count::get(),
ADD_STAT(numIntRegReads, Stats::units::Count::get(),
"Number of times the integer registers were read"),
ADD_STAT(numIntRegWrites, Stats::Units::Count::get(),
ADD_STAT(numIntRegWrites, Stats::units::Count::get(),
"Number of times the integer registers were written"),
ADD_STAT(numFpRegReads, Stats::Units::Count::get(),
ADD_STAT(numFpRegReads, Stats::units::Count::get(),
"Number of times the floating registers were read"),
ADD_STAT(numFpRegWrites, Stats::Units::Count::get(),
ADD_STAT(numFpRegWrites, Stats::units::Count::get(),
"Number of times the floating registers were written"),
ADD_STAT(numVecRegReads, Stats::Units::Count::get(),
ADD_STAT(numVecRegReads, Stats::units::Count::get(),
"Number of times the vector registers were read"),
ADD_STAT(numVecRegWrites, Stats::Units::Count::get(),
ADD_STAT(numVecRegWrites, Stats::units::Count::get(),
"Number of times the vector registers were written"),
ADD_STAT(numVecPredRegReads, Stats::Units::Count::get(),
ADD_STAT(numVecPredRegReads, Stats::units::Count::get(),
"Number of times the predicate registers were read"),
ADD_STAT(numVecPredRegWrites, Stats::Units::Count::get(),
ADD_STAT(numVecPredRegWrites, Stats::units::Count::get(),
"Number of times the predicate registers were written"),
ADD_STAT(numCCRegReads, Stats::Units::Count::get(),
ADD_STAT(numCCRegReads, Stats::units::Count::get(),
"Number of times the CC registers were read"),
ADD_STAT(numCCRegWrites, Stats::Units::Count::get(),
ADD_STAT(numCCRegWrites, Stats::units::Count::get(),
"Number of times the CC registers were written"),
ADD_STAT(numMemRefs, Stats::Units::Count::get(),
ADD_STAT(numMemRefs, Stats::units::Count::get(),
"Number of memory refs"),
ADD_STAT(numLoadInsts, Stats::Units::Count::get(),
ADD_STAT(numLoadInsts, Stats::units::Count::get(),
"Number of load instructions"),
ADD_STAT(numStoreInsts, Stats::Units::Count::get(),
ADD_STAT(numStoreInsts, Stats::units::Count::get(),
"Number of store instructions"),
ADD_STAT(numIdleCycles, Stats::Units::Cycle::get(),
ADD_STAT(numIdleCycles, Stats::units::Cycle::get(),
"Number of idle cycles"),
ADD_STAT(numBusyCycles, Stats::Units::Cycle::get(),
ADD_STAT(numBusyCycles, Stats::units::Cycle::get(),
"Number of busy cycles"),
ADD_STAT(notIdleFraction, Stats::Units::Ratio::get(),
ADD_STAT(notIdleFraction, Stats::units::Ratio::get(),
"Percentage of non-idle cycles"),
ADD_STAT(idleFraction, Stats::Units::Ratio::get(),
ADD_STAT(idleFraction, Stats::units::Ratio::get(),
"Percentage of idle cycles"),
ADD_STAT(icacheStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(icacheStallCycles, Stats::units::Cycle::get(),
"ICache total stall cycles"),
ADD_STAT(dcacheStallCycles, Stats::Units::Cycle::get(),
ADD_STAT(dcacheStallCycles, Stats::units::Cycle::get(),
"DCache total stall cycles"),
ADD_STAT(numBranches, Stats::Units::Count::get(),
ADD_STAT(numBranches, Stats::units::Count::get(),
"Number of branches fetched"),
ADD_STAT(numPredictedBranches, Stats::Units::Count::get(),
ADD_STAT(numPredictedBranches, Stats::units::Count::get(),
"Number of branches predicted as taken"),
ADD_STAT(numBranchMispred, Stats::Units::Count::get(),
ADD_STAT(numBranchMispred, Stats::units::Count::get(),
"Number of branch mispredictions"),
ADD_STAT(statExecutedInstType, Stats::Units::Count::get(),
ADD_STAT(statExecutedInstType, Stats::units::Count::get(),
"Class of executed instruction.")
{
numCCRegReads

4
src/cpu/testers/memtest/memtest.cc
View File

@@ -191,9 +191,9 @@ MemTest::completeRequest(PacketPtr pkt, bool functional)
}
MemTest::MemTestStats::MemTestStats(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(numReads, Stats::Units::Count::get(),
ADD_STAT(numReads, Stats::units::Count::get(),
"number of read accesses completed"),
ADD_STAT(numWrites, Stats::Units::Count::get(),
ADD_STAT(numWrites, Stats::units::Count::get(),
"number of write accesses completed")
{

36
src/cpu/testers/traffic_gen/base.cc
View File

@@ -332,34 +332,34 @@ BaseTrafficGen::noProgress()
BaseTrafficGen::StatGroup::StatGroup(Stats::Group *parent)
: Stats::Group(parent),
ADD_STAT(numSuppressed, Stats::Units::Count::get(),
ADD_STAT(numSuppressed, Stats::units::Count::get(),
"Number of suppressed packets to non-memory space"),
ADD_STAT(numPackets, Stats::Units::Count::get(),
ADD_STAT(numPackets, Stats::units::Count::get(),
"Number of packets generated"),
ADD_STAT(numRetries, Stats::Units::Count::get(), "Number of retries"),
ADD_STAT(retryTicks, Stats::Units::Tick::get(),
ADD_STAT(numRetries, Stats::units::Count::get(), "Number of retries"),
ADD_STAT(retryTicks, Stats::units::Tick::get(),
"Time spent waiting due to back-pressure"),
ADD_STAT(bytesRead, Stats::Units::Byte::get(), "Number of bytes read"),
ADD_STAT(bytesWritten, Stats::Units::Byte::get(),
ADD_STAT(bytesRead, Stats::units::Byte::get(), "Number of bytes read"),
ADD_STAT(bytesWritten, Stats::units::Byte::get(),
"Number of bytes written"),
ADD_STAT(totalReadLatency, Stats::Units::Tick::get(),
ADD_STAT(totalReadLatency, Stats::units::Tick::get(),
"Total latency of read requests"),
ADD_STAT(totalWriteLatency, Stats::Units::Tick::get(),
ADD_STAT(totalWriteLatency, Stats::units::Tick::get(),
"Total latency of write requests"),
ADD_STAT(totalReads, Stats::Units::Count::get(), "Total num of reads"),
ADD_STAT(totalWrites, Stats::Units::Count::get(), "Total num of writes"),
ADD_STAT(avgReadLatency, Stats::Units::Rate<
Stats::Units::Tick, Stats::Units::Count>::get(),
ADD_STAT(totalReads, Stats::units::Count::get(), "Total num of reads"),
ADD_STAT(totalWrites, Stats::units::Count::get(), "Total num of writes"),
ADD_STAT(avgReadLatency, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
"Avg latency of read requests", totalReadLatency / totalReads),
ADD_STAT(avgWriteLatency, Stats::Units::Rate<
Stats::Units::Tick, Stats::Units::Count>::get(),
ADD_STAT(avgWriteLatency, Stats::units::Rate<
Stats::units::Tick, Stats::units::Count>::get(),
"Avg latency of write requests",
totalWriteLatency / totalWrites),
ADD_STAT(readBW, Stats::Units::Rate<
Stats::Units::Byte, Stats::Units::Second>::get(),
ADD_STAT(readBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
"Read bandwidth", bytesRead / simSeconds),
ADD_STAT(writeBW, Stats::Units::Rate<
Stats::Units::Byte, Stats::Units::Second>::get(),
ADD_STAT(writeBW, Stats::units::Rate<
Stats::units::Byte, Stats::units::Second>::get(),
"Write bandwidth", bytesWritten / simSeconds)
{
}

6
src/cpu/thread_state.cc
View File

@@ -117,10 +117,10 @@ ThreadState::getVirtProxy()
ThreadState::ThreadStateStats::ThreadStateStats(BaseCPU *cpu,
const ThreadID& tid)
: Stats::Group(cpu, csprintf("thread_%i", tid).c_str()),
ADD_STAT(numInsts, Stats::Units::Count::get(),
ADD_STAT(numInsts, Stats::units::Count::get(),
"Number of Instructions committed"),
ADD_STAT(numOps, Stats::Units::Count::get(), "Number of Ops committed"),
ADD_STAT(numMemRefs, Stats::Units::Count::get(),
ADD_STAT(numOps, Stats::units::Count::get(), "Number of Ops committed"),
ADD_STAT(numMemRefs, Stats::units::Count::get(),
"Number of Memory References")
{

40
src/cpu/trace/trace_cpu.cc
View File

@@ -203,15 +203,15 @@ TraceCPU::checkAndSchedExitEvent()
}
TraceCPU::TraceStats::TraceStats(TraceCPU *trace) :
Stats::Group(trace),
ADD_STAT(numSchedDcacheEvent, Stats::Units::Count::get(),
ADD_STAT(numSchedDcacheEvent, Stats::units::Count::get(),
"Number of events scheduled to trigger data request generator"),
ADD_STAT(numSchedIcacheEvent, Stats::Units::Count::get(),
ADD_STAT(numSchedIcacheEvent, Stats::units::Count::get(),
"Number of events scheduled to trigger instruction request "
"generator"),
ADD_STAT(numOps, Stats::Units::Count::get(),
ADD_STAT(numOps, Stats::units::Count::get(),
"Number of micro-ops simulated by the Trace CPU"),
ADD_STAT(cpi, Stats::Units::Rate<
Stats::Units::Cycle, Stats::Units::Count>::get(),
ADD_STAT(cpi, Stats::units::Rate<
Stats::units::Cycle, Stats::units::Count>::get(),
"Cycles per micro-op used as a proxy for CPI",
trace->baseStats.numCycles / numOps)
{
@@ -222,25 +222,25 @@ TraceCPU::ElasticDataGen::
ElasticDataGenStatGroup::ElasticDataGenStatGroup(Stats::Group *parent,
const std::string& _name) :
Stats::Group(parent, _name.c_str()),
ADD_STAT(maxDependents, Stats::Units::Count::get(),
ADD_STAT(maxDependents, Stats::units::Count::get(),
"Max number of dependents observed on a node"),
ADD_STAT(maxReadyListSize, Stats::Units::Count::get(),
ADD_STAT(maxReadyListSize, Stats::units::Count::get(),
"Max size of the ready list observed"),
ADD_STAT(numSendAttempted, Stats::Units::Count::get(),
ADD_STAT(numSendAttempted, Stats::units::Count::get(),
"Number of first attempts to send a request"),
ADD_STAT(numSendSucceeded, Stats::Units::Count::get(),
ADD_STAT(numSendSucceeded, Stats::units::Count::get(),
"Number of successful first attempts"),
ADD_STAT(numSendFailed, Stats::Units::Count::get(),
ADD_STAT(numSendFailed, Stats::units::Count::get(),
"Number of failed first attempts"),
ADD_STAT(numRetrySucceeded, Stats::Units::Count::get(),
ADD_STAT(numRetrySucceeded, Stats::units::Count::get(),
"Number of successful retries"),
ADD_STAT(numSplitReqs, Stats::Units::Count::get(),
ADD_STAT(numSplitReqs, Stats::units::Count::get(),
"Number of split requests"),
ADD_STAT(numSOLoads, Stats::Units::Count::get(),
ADD_STAT(numSOLoads, Stats::units::Count::get(),
"Number of strictly ordered loads"),
ADD_STAT(numSOStores, Stats::Units::Count::get(),
ADD_STAT(numSOStores, Stats::units::Count::get(),
"Number of strictly ordered stores"),
ADD_STAT(dataLastTick, Stats::Units::Tick::get(),
ADD_STAT(dataLastTick, Stats::units::Tick::get(),
"Last tick simulated from the elastic data trace")
{
}
@@ -968,15 +968,15 @@ TraceCPU::ElasticDataGen::HardwareResource::printOccupancy()
TraceCPU::FixedRetryGen::FixedRetryGenStatGroup::FixedRetryGenStatGroup(
Stats::Group *parent, const std::string& _name) :
Stats::Group(parent, _name.c_str()),
ADD_STAT(numSendAttempted, Stats::Units::Count::get(),
ADD_STAT(numSendAttempted, Stats::units::Count::get(),
"Number of first attempts to send a request"),
ADD_STAT(numSendSucceeded, Stats::Units::Count::get(),
ADD_STAT(numSendSucceeded, Stats::units::Count::get(),
"Number of successful first attempts"),
ADD_STAT(numSendFailed, Stats::Units::Count::get(),
ADD_STAT(numSendFailed, Stats::units::Count::get(),
"Number of failed first attempts"),
ADD_STAT(numRetrySucceeded, Stats::Units::Count::get(),
ADD_STAT(numRetrySucceeded, Stats::units::Count::get(),
"Number of successful retries"),
ADD_STAT(instLastTick, Stats::Units::Tick::get(),
ADD_STAT(instLastTick, Stats::units::Tick::get(),
"Last tick simulated from the fixed inst trace")
{