/// <summary>
/// Update counter values for thread, and add to totals
/// Will set thread affinity
/// </summary>
/// <param name="threadIdx">thread in question</param>
public void UpdateThreadCoreCounterData(int threadIdx)
{
ThreadAffinity.Set(1UL << threadIdx);
float normalizationFactor = GetNormalizationFactor(threadIdx);
float joules;
ulong aperf, mperf, tsc, instr;
ulong ctr0, ctr1, ctr2, ctr3, ctr4, ctr5;
ReadFixedCounters(threadIdx, out aperf, out instr, out tsc, out mperf);
ctr0 = ReadAndClearMsr(MSR_PERF_CTR_0);
ctr1 = ReadAndClearMsr(MSR_PERF_CTR_1);
ctr2 = ReadAndClearMsr(MSR_PERF_CTR_2);
ctr3 = ReadAndClearMsr(MSR_PERF_CTR_3);
ctr4 = ReadAndClearMsr(MSR_PERF_CTR_4);
ctr5 = ReadAndClearMsr(MSR_PERF_CTR_5);
ReadCorePowerCounter(threadIdx, out joules);
if (NormalizedThreadCounts == null)
{
NormalizedThreadCounts = new NormalizedCoreCounterData[threadCount];
}
if (NormalizedThreadCounts[threadIdx] == null)
{
NormalizedThreadCounts[threadIdx] = new NormalizedCoreCounterData();
}
NormalizedThreadCounts[threadIdx].aperf = aperf * normalizationFactor;
NormalizedThreadCounts[threadIdx].mperf = mperf * normalizationFactor;
NormalizedThreadCounts[threadIdx].instr = instr * normalizationFactor;
NormalizedThreadCounts[threadIdx].tsc = tsc * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr0 = ctr0 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr1 = ctr1 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr2 = ctr2 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr3 = ctr3 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr4 = ctr4 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr5 = ctr5 * normalizationFactor;
NormalizedThreadCounts[threadIdx].watts = joules * normalizationFactor;
NormalizedThreadCounts[threadIdx].NormalizationFactor = normalizationFactor;
NormalizedTotalCounts.aperf += NormalizedThreadCounts[threadIdx].aperf;
NormalizedTotalCounts.mperf += NormalizedThreadCounts[threadIdx].mperf;
NormalizedTotalCounts.instr += NormalizedThreadCounts[threadIdx].instr;
NormalizedTotalCounts.tsc += NormalizedThreadCounts[threadIdx].tsc;
NormalizedTotalCounts.ctr0 += NormalizedThreadCounts[threadIdx].ctr0;
NormalizedTotalCounts.ctr1 += NormalizedThreadCounts[threadIdx].ctr1;
NormalizedTotalCounts.ctr2 += NormalizedThreadCounts[threadIdx].ctr2;
NormalizedTotalCounts.ctr3 += NormalizedThreadCounts[threadIdx].ctr3;
NormalizedTotalCounts.ctr4 += NormalizedThreadCounts[threadIdx].ctr4;
NormalizedTotalCounts.ctr5 += NormalizedThreadCounts[threadIdx].ctr5;
// only add core power once per core. don't count it per-SMT thread
// and always add if SMT is off (thread count == core count)
if (threadCount == coreCount || (threadCount == coreCount * 2 && threadIdx % 2 == 0))
{
NormalizedTotalCounts.totalCoreWatts += NormalizedThreadCounts[threadIdx].watts;
}
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.aperf),
FormatLargeNumber(counterData.ctr0),
FormatLargeNumber(counterData.ctr2),
FormatLargeNumber(counterData.ctr3) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.ctr0),
FormatLargeNumber(counterData.ctr1),
string.Format("{0:F2}", counterData.ctr1 / counterData.ctr0),
FormatLargeNumber(counterData.ctr2 * 64) + "B/s",
FormatLargeNumber(counterData.ctr3 * 64) + "B/s",
FormatLargeNumber(counterData.ctr4 * 64) + "B/s",
FormatLargeNumber(counterData.ctr5 * 64) + "B/s", });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2}%", counterData.pmc0 / counterData.activeCycles * 100),
string.Format("{0:F2}%", counterData.pmc1 / counterData.activeCycles * 100),
string.Format("{0:F2}%", counterData.pmc2 / counterData.activeCycles * 100),
string.Format("{0:F2}%", counterData.pmc3 / counterData.activeCycles * 100) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.ctr3),
FormatLargeNumber(counterData.ctr2),
string.Format("{0:F2}", counterData.ctr2 / counterData.ctr3),
string.Format("{0:F2}%", 100 * (1 - counterData.ctr1 / counterData.ctr0)),
string.Format("{0:F2}", counterData.ctr1 / counterData.ctr3 * 1000),
FormatLargeNumber(counterData.ctr0),
FormatLargeNumber(counterData.ctr1),
FormatLargeNumber(counterData.ctr5) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2} W", counterData.packagePower),
FormatLargeNumber(counterData.instr / counterData.packagePower),
string.Format("{0:F2}%", 100 * counterData.pmc0 / (counterData.pmc0 + counterData.pmc1)),
string.Format("{0:F2}", 1000 * counterData.pmc1 / counterData.instr),
string.Format("{0:F2}", 1000 * (counterData.pmc2 + counterData.pmc3) / counterData.instr),
string.Format("{0:F2}", 1000 * counterData.pmc3 / counterData.instr) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.aperf),
string.Format("{0:F2}%", 100 * (1 - counterData.ctr1 / counterData.ctr0)),
FormatLargeNumber(64 * counterData.ctr0 - counterData.ctr1) + "B/s",
string.Format("{0:F2}%", 100 * (1 - counterData.ctr3 / counterData.ctr2)),
FormatLargeNumber(64 * counterData.ctr3 - counterData.ctr2) + "B/s",
FormatLargeNumber(counterData.ctr4),
FormatLargeNumber(counterData.ctr5) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2} W", counterData.packagePower),
FormatLargeNumber(counterData.instr / counterData.packagePower),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2}%", 100 * (counterData.pmc0 - counterData.pmc1) / counterData.pmc0),
FormatLargeNumber((counterData.pmc0 - counterData.pmc1) * 64) + "B",
FormatLargeNumber(counterData.pmc2 * 64) + "B",
FormatLargeNumber(counterData.pmc3 * 64) + "B", });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2} W", counterData.packagePower),
FormatLargeNumber(counterData.instr / counterData.packagePower),
FormatPercentage(counterData.pmc0, counterData.activeCycles),
FormatPercentage(counterData.pmc1, counterData.activeCycles),
FormatPercentage(counterData.pmc2, counterData.activeCycles),
FormatPercentage(counterData.pmc3, counterData.activeCycles) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float instr = counterData.ctr4;
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf),
FormatPercentage((counterData.ctr5 - counterData.ctr0 - counterData.ctr1), counterData.ctr5),
string.Format("{0:F2}", 1000 * (counterData.ctr0 + counterData.ctr1) / instr),
FormatPercentage(counterData.ctr0, counterData.ctr0 + counterData.ctr1),
string.Format("{0:F2}", 1000 * counterData.ctr1 / instr),
string.Format("{0:F2}", 1000 * counterData.ctr2 / instr) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.aperf),
FormatPercentage(counterData.ctr0 + counterData.ctr1, counterData.aperf),
FormatPercentage(counterData.ctr0, counterData.aperf),
FormatPercentage(counterData.ctr1, counterData.aperf),
FormatPercentage(counterData.ctr2, counterData.aperf),
string.Format("{0:F2}", counterData.ctr3 / counterData.aperf),
FormatPercentage(counterData.ctr4, counterData.aperf),
FormatPercentage(counterData.ctr5, counterData.aperf), }); // fused branches
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.aperf),
string.Format("{0:F2}%", 100 * (1 - counterData.ctr1 / counterData.ctr0)), // bpu acc
string.Format("{0:F2}", counterData.ctr1 / counterData.aperf * 1000), // branch mpki
string.Format("{0:F2}%", 100 * counterData.ctr0 / counterData.instr), // % branches
string.Format("{0:F2}", 1000 * counterData.ctr2 / counterData.instr), // l2 btb overrides
string.Format("{0:F2}", 1000 * counterData.ctr3 / counterData.instr), // ita overrides
string.Format("{0:F2}", 1000 * counterData.ctr4 / counterData.instr), // decoder overrides
string.Format("{0:F2}%", counterData.ctr5 / counterData.ctr0 * 100) }); // fused branches
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float instr = counterData.ctr2;
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf),
string.Format("{0:F2}%", 100 * (1 - counterData.ctr5 / counterData.ctr4)), // BPU Acc
string.Format("{0:F2}", counterData.ctr5 / instr * 1000), // BPU MPKI
FormatPercentage(counterData.ctr4, instr), // % branches
FormatPercentage(counterData.ctr3, counterData.ctr4), // % branches taken
FormatLargeNumber(counterData.ctr0),
FormatLargeNumber(counterData.ctr1) }); // Branch %
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float cycles = counterData.ctr4;
float instr = counterData.ctr5;
return(new string[] { label,
FormatLargeNumber(cycles),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / cycles),
string.Format("{0:F2} W", counterData.watts),
FormatLargeNumber(instr / counterData.watts),
FormatPercentage(counterData.ctr0, cycles),
FormatPercentage(counterData.ctr1, cycles),
FormatPercentage(counterData.ctr2, cycles),
FormatPercentage(counterData.ctr3, cycles) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float ipc = counterData.instr / counterData.activeCycles;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", ipc),
string.Format("{0:F2}%", 100 * (counterData.pmc0 + counterData.pmc1) / (counterData.pmc0 + counterData.pmc1 + counterData.pmc2 + counterData.pmc3)),
string.Format("{0:F2}%", 100 * counterData.pmc0 / (counterData.pmc0 + counterData.pmc2)),
string.Format("{0:F2}%", 100 * counterData.pmc1 / (counterData.pmc1 + counterData.pmc3)),
FormatLargeNumber(counterData.pmc0),
FormatLargeNumber(counterData.pmc0 + counterData.pmc2),
FormatLargeNumber(counterData.pmc1),
FormatLargeNumber(counterData.pmc1 + counterData.pmc3) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float instr = counterData.ctr3;
float L2Hits = counterData.ctr0 - counterData.ctr1;
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf),
FormatPercentage(L2Hits, counterData.ctr0),
FormatLargeNumber(64 * L2Hits) + "B/s",
string.Format("{0:F2}", 1000 * counterData.ctr1 / instr),
FormatLargeNumber(64 * counterData.ctr2) + "B/s",
FormatLargeNumber(counterData.ctr4),
FormatLargeNumber(counterData.ctr5) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float instr = counterData.ctr3;
float dcHits = counterData.ctr5 - counterData.ctr4;
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf),
FormatPercentage(dcHits, counterData.ctr5),
string.Format("{0:F2}", 1000 * counterData.ctr4 / instr),
FormatLargeNumber(16 * dcHits) + "B/s", // each data cache hit should be 16B
FormatLargeNumber(64 * (counterData.ctr4 - counterData.ctr2)) + "B/s",
FormatLargeNumber(64 * counterData.ctr2) + "B/s",
FormatPercentage(counterData.ctr0, counterData.aperf),
FormatPercentage(counterData.ctr1, counterData.aperf) });
}
/// <summary>
/// initialize/reset accumulated totals for core counter data
/// </summary>
public void InitializeCoreTotals()
{
if (NormalizedTotalCounts == null)
{
NormalizedTotalCounts = new NormalizedCoreCounterData();
}
NormalizedTotalCounts.aperf = 0;
NormalizedTotalCounts.mperf = 0;
NormalizedTotalCounts.tsc = 0;
NormalizedTotalCounts.ctr0 = 0;
NormalizedTotalCounts.ctr1 = 0;
NormalizedTotalCounts.ctr2 = 0;
NormalizedTotalCounts.ctr3 = 0;
NormalizedTotalCounts.ctr4 = 0;
NormalizedTotalCounts.ctr5 = 0;
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData, bool overall)
{
float ipc = counterData.instr / counterData.activeCycles;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", ipc),
overall ? string.Format("{0:F2} W", counterData.packagePower) : "N/A",
overall ? string.Format("{0:F2} W", counterData.pp0Power) : "N/A",
overall ? FormatLargeNumber(counterData.instr / counterData.packagePower) : "N/A",
overall ? FormatLargeNumber(counterData.instr / counterData.pp0Power) : "N/A",
string.Format("{0:F2}%", 100 * counterData.pmc0 / counterData.activeCycles),
string.Format("{0:F2}%", 100 * counterData.pmc1 / counterData.activeCycles),
string.Format("{0:F2}%", 100 * counterData.pmc2 / counterData.activeCycles),
string.Format("{0:F2}%", 100 * counterData.pmc3 / counterData.activeCycles) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData, bool overall)
{
float oneOp = counterData.pmc0 - counterData.pmc1;
float twoOps = counterData.pmc1 - counterData.pmc2;
float threeOps = counterData.pmc2 - counterData.pmc3;
float opCacheOps = oneOp + 2 * twoOps + 3 * threeOps + 4 * counterData.pmc3;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
overall ? string.Format("{0:F2} W", counterData.packagePower) : "N/A",
overall ? FormatLargeNumber(counterData.instr / counterData.packagePower) : "N/A",
FormatLargeNumber(64 * counterData.pmc1) + "B/s",
string.Format("{0:F2} clk", counterData.pmc0 / counterData.pmc1),
FormatPercentage(counterData.pmc2, counterData.activeCycles),
FormatPercentage(counterData.pmc3, counterData.activeCycles), });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float instr = counterData.ctr3;
float icHits = counterData.ctr0 - (counterData.ctr1 + counterData.ctr2);
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf), // IPC
string.Format("{0:F2}", counterData.ctr4 / counterData.aperf), // Uops/c
string.Format("{0:F2}", counterData.ctr4 / instr), // Uops/instr
FormatPercentage(counterData.ctr0 - (counterData.ctr1 + counterData.ctr2), counterData.ctr0), // IC hitrate
FormatLargeNumber(32 * icHits) + "B/s", // IC Hit BW
string.Format("{0:F2}", 1000 * (counterData.ctr1 + counterData.ctr2) / instr), // IC MPKI
FormatLargeNumber(64 * counterData.ctr1) + "B/s", // IC refill from L2
FormatLargeNumber(64 * counterData.ctr2) + "B/s", // IC refill from system
FormatLargeNumber(counterData.ctr5) });
}
/// <summary>
/// Read and update counter data for thread
/// </summary>
/// <param name="threadIdx">Thread to set affinity to</param>
public void UpdateThreadCoreCounterData(int threadIdx)
{
ThreadAffinity.Set(1UL << threadIdx);
float normalizationFactor = GetNormalizationFactor(threadIdx);
ulong aperf, mperf, tsc;
ulong ctr0, ctr1, ctr2, ctr3, ctr4, ctr5;
ReadFixedCounters(threadIdx, out aperf, out tsc, out mperf);
ctr0 = ReadAndClearMsr(MSR_PERF_CTR_0);
ctr1 = ReadAndClearMsr(MSR_PERF_CTR_1);
ctr2 = ReadAndClearMsr(MSR_PERF_CTR_2);
ctr3 = ReadAndClearMsr(MSR_PERF_CTR_3);
ctr4 = ReadAndClearMsr(MSR_PERF_CTR_4);
ctr5 = ReadAndClearMsr(MSR_PERF_CTR_5);
if (NormalizedThreadCounts == null)
{
NormalizedThreadCounts = new NormalizedCoreCounterData[threadCount];
}
if (NormalizedThreadCounts[threadIdx] == null)
{
NormalizedThreadCounts[threadIdx] = new NormalizedCoreCounterData();
}
NormalizedThreadCounts[threadIdx].aperf = aperf * normalizationFactor;
NormalizedThreadCounts[threadIdx].mperf = mperf * normalizationFactor;
NormalizedThreadCounts[threadIdx].tsc = tsc * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr0 = ctr0 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr1 = ctr1 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr2 = ctr2 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr3 = ctr3 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr4 = ctr4 * normalizationFactor;
NormalizedThreadCounts[threadIdx].ctr5 = ctr5 * normalizationFactor;
NormalizedThreadCounts[threadIdx].NormalizationFactor = normalizationFactor;
NormalizedTotalCounts.aperf += NormalizedThreadCounts[threadIdx].aperf;
NormalizedTotalCounts.mperf += NormalizedThreadCounts[threadIdx].mperf;
NormalizedTotalCounts.tsc += NormalizedThreadCounts[threadIdx].tsc;
NormalizedTotalCounts.ctr0 += NormalizedThreadCounts[threadIdx].ctr0;
NormalizedTotalCounts.ctr1 += NormalizedThreadCounts[threadIdx].ctr1;
NormalizedTotalCounts.ctr2 += NormalizedThreadCounts[threadIdx].ctr2;
NormalizedTotalCounts.ctr3 += NormalizedThreadCounts[threadIdx].ctr3;
NormalizedTotalCounts.ctr4 += NormalizedThreadCounts[threadIdx].ctr4;
NormalizedTotalCounts.ctr5 += NormalizedThreadCounts[threadIdx].ctr5;
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float oneOp = counterData.pmc0 - counterData.pmc1;
float twoOps = counterData.pmc1 - counterData.pmc2;
float threeOps = counterData.pmc2 - counterData.pmc3;
float opsIssued = oneOp + 2 * twoOps + 3 * threeOps + 4 * counterData.pmc3;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
FormatLargeNumber(opsIssued),
string.Format("{0:F2}", opsIssued / counterData.activeCycles),
string.Format("{0:F2}%", 100 * oneOp / counterData.activeCycles),
string.Format("{0:F2}%", 100 * twoOps / counterData.activeCycles),
string.Format("{0:F2}%", 100 * threeOps / counterData.activeCycles),
string.Format("{0:F2}%", 100 * counterData.pmc3 / counterData.activeCycles),
string.Format("{0:F2}%", 100 * counterData.pmc0 / counterData.activeCycles), });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float l1LfbHit = counterData.pmc0 - counterData.pmc1;
float l2Hit = counterData.pmc1 - counterData.pmc2;
float l3hit = counterData.pmc2 - counterData.pmc3;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
FormatLargeNumber(counterData.pmc0),
string.Format("{0:F2}%", 100 * l1LfbHit / counterData.pmc0),
string.Format("{0:F2}", 1000 * counterData.pmc1 / counterData.instr),
string.Format("{0:F2}%", 100 * l2Hit / counterData.pmc0),
string.Format("{0:F2}", 1000 * counterData.pmc2 / counterData.instr),
string.Format("{0:F2}%", 100 * l3hit / counterData.pmc0),
string.Format("{0:F2}", 1000 * counterData.pmc3 / counterData.instr),
string.Format("{0:F2}%", 100 * counterData.pmc3 / counterData.pmc0), });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float cycles = counterData.ctr0;
float instr = counterData.ctr1;
float branches = counterData.ctr2;
float mispBranches = counterData.ctr3;
float l1BtbOverrides = counterData.ctr4;
float l2BtbOverrides = counterData.ctr5;
return(new string[] { label,
FormatLargeNumber(cycles),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / cycles),
string.Format("{0:F2} W", counterData.watts),
FormatLargeNumber(instr / counterData.watts),
string.Format("{0:F2}%", 100 * (1 - mispBranches / branches)), // BPU Acc
string.Format("{0:F2}", mispBranches / instr * 1000), // BPU MPKI
string.Format("{0:F2}", l1BtbOverrides / instr * 1000), // L1 BTB Overrides
string.Format("{0:F2}", l2BtbOverrides / instr * 1000), // L2 BTB Overrides
string.Format("{0:F2}%", branches / instr * 100) }); // Branch %
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float scalarFlops = counterData.pmc0;
float flops128b = counterData.pmc1 * 4;
float flops256b = counterData.pmc2 * 8;
float totalFlops = scalarFlops + flops128b + flops256b;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2} W", counterData.packagePower),
FormatLargeNumber(counterData.instr / counterData.packagePower),
FormatLargeNumber(totalFlops),
FormatLargeNumber(scalarFlops),
FormatLargeNumber(flops128b),
FormatLargeNumber(flops256b),
FormatLargeNumber(counterData.pmc3),
string.Format("{0:F2}", totalFlops / counterData.activeCycles),
FormatPercentage(counterData.pmc3, counterData.instr) });
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData)
{
float retireSlotsUsed = (counterData.pmc0 - counterData.pmc1) +
2 * (counterData.pmc1 - counterData.pmc2) +
3 * (counterData.pmc2 - counterData.pmc3) +
4 * counterData.pmc3;
return(new string[] { label,
FormatLargeNumber(counterData.activeCycles),
FormatLargeNumber(counterData.instr),
string.Format("{0:F2}", counterData.instr / counterData.activeCycles),
string.Format("{0:F2} W", counterData.packagePower),
FormatLargeNumber(counterData.instr / counterData.packagePower),
FormatLargeNumber(retireSlotsUsed),
string.Format("{0:F2}", retireSlotsUsed / counterData.instr),
string.Format("{0:F2}", retireSlotsUsed / counterData.activeCycles),
FormatPercentage(counterData.pmc0, counterData.activeCycles), // retire active - at least 1 slot used
FormatPercentage(counterData.pmc0 - counterData.pmc1, counterData.activeCycles), // 1 slot
FormatPercentage(counterData.pmc1 - counterData.pmc2, counterData.activeCycles), // 2 slots
FormatPercentage(counterData.pmc2 - counterData.pmc3, counterData.activeCycles), // 3 slots
FormatPercentage(counterData.pmc3, counterData.activeCycles) // 4 slots
});
}
private string[] computeMetrics(string label, NormalizedCoreCounterData counterData, int threadId)
{
float fp0 = 0, fp1 = 0, fp2 = 0, fp3 = 0;
if (threadId < 0)
{
for (int i = 0; i < cpu.GetThreadCount(); i++)
{
fp0 += lastPipeCounts[i * 4];
fp1 += lastPipeCounts[i * 4 + 1];
fp2 += lastPipeCounts[i * 4 + 2];
fp3 += lastPipeCounts[i * 4 + 3];
}
}
else
{
fp0 = lastPipeCounts[threadId * 4];
fp1 = lastPipeCounts[threadId * 4 + 1];
fp2 = lastPipeCounts[threadId * 4 + 2];
fp3 = lastPipeCounts[threadId * 4 + 3];
}
float instr = counterData.ctr0;
return(new string[] { label,
FormatLargeNumber(counterData.aperf),
FormatLargeNumber(instr),
string.Format("{0:F2}", instr / counterData.aperf),
FormatLargeNumber(counterData.ctr1),
FormatLargeNumber(counterData.ctr2),
FormatPercentage(fp0, counterData.aperf),
FormatPercentage(fp1, counterData.aperf),
FormatPercentage(fp2, counterData.aperf),
FormatPercentage(fp3, counterData.aperf),
FormatPercentage(counterData.ctr4, counterData.aperf),
FormatLargeNumber(counterData.ctr5) });
}
