# -*- coding: latin-1 -*-

#

# auto generated TopDown/TMA 4 description for Intel 14th gen Core (code name Meteorlake) with Crestmont

# Please see http://ark.intel.com for more details on these CPUs.

#

# References:

# http://bit.ly/tma-ispass14

# http://halobates.de/blog/p/262

# https://sites.google.com/site/analysismethods/yasin-pubs

# https://download.01.org/perfmon/

# https://github.com/andikleen/pmu-tools/wiki/toplev-manual

#

# Helpers

print_error = lambda msg: False

version = "4"

base_frequency = -1.0

Memory = 0

Average_Frequency = 0.0

num_cores = 1

num_threads = 1

num_sockets = 1

def handle_error(obj, msg):

obj.thresh = False

def handle_error_metric(obj, msg):

print_error(msg)

obj.errcount += 1

obj.val = 0

# Constants

Pipeline_Width = 6

# Aux. formulas

def CLKS(self, EV, level):

return EV("CPU_CLK_UNHALTED.CORE", level)

def SLOTS(self, EV, level):

return Pipeline_Width * CLKS(self, EV, level)

def DurationTimeInSeconds(self, EV, level):

return EV("interval-ms", 0) / 1000

# Percentage of time that retirement is stalled by the Memory Cluster due to a pipeline stall. See Info.Mem_Exec_Bound

def PCT_Mem_Exec_Bound_Cycles(self, EV, level):

return 100 * EV("LD_HEAD.ANY_AT_RET", level) / CLKS(self, EV, level)

# Percentage of time that retirement is stalled due to an L1 miss. See Info.Load_Miss_Bound

def PCT_Load_Miss_Bound_Cycles(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_LOAD.ALL", level) / CLKS(self, EV, level)

# Percentage of time that retirement is stalled due to a first level data TLB miss

def PCT_DTLB_Miss_Bound_Cycles(self, EV, level):

return 100 *(EV("LD_HEAD.DTLB_MISS_AT_RET", level) + EV("LD_HEAD.PGWALK_AT_RET", level)) / CLKS(self, EV, level)

# Percentage of time that allocation and retirement is stalled by the Frontend Cluster due to an Ifetch Miss, either Icache or ITLB Miss. See Info.Ifetch_Bound

def PCT_IFetch_Miss_Bound_Cycles(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_IFETCH.ALL", level) / CLKS(self, EV, level)

# Instructions Per Cycle

def IPC(self, EV, level):

return EV("INST_RETIRED.ANY", level) / CLKS(self, EV, level)

# Cycles Per Instruction

def CPI(self, EV, level):

return CLKS(self, EV, level) / EV("INST_RETIRED.ANY", level)

# Uops Per Instruction

def UPI(self, EV, level):

return EV("TOPDOWN_RETIRING.ALL_P", level) / EV("INST_RETIRED.ANY", level)

# Floating Point Operations Per Cycle

def FLOPc(self, EV, level):

return EV("FP_FLOPS_RETIRED.ALL", level) / CLKS(self, EV, level)

# Instructions per Branch (lower number means higher occurrence rate)

def IpBranch(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_INST_RETIRED.ALL_BRANCHES", level)

# Instruction per (near) call (lower number means higher occurrence rate)

def IpCall(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_INST_RETIRED.NEAR_CALL", level)

# Instructions per Far Branch ( Far Branches apply upon transition from application to operating system, handling interrupts, exceptions) [lower number means higher occurrence rate]

def IpFarBranch(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_INST_RETIRED.FAR_BRANCH:USER", level)

# Instructions per retired Branch Misprediction

def IpMispredict(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_MISP_RETIRED.ALL_BRANCHES", level)

# Instructions per retired conditional Branch Misprediction where the branch was not taken

def IpMisp_Cond_Ntaken(self, EV, level):

return EV("INST_RETIRED.ANY", level) / (EV("BR_MISP_RETIRED.COND", level) - EV("BR_MISP_RETIRED.COND_TAKEN", level))

# Instructions per retired conditional Branch Misprediction where the branch was taken

def IpMisp_Cond_Taken(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_MISP_RETIRED.COND_TAKEN", level)

# Instructions per retired return Branch Misprediction

def IpMisp_Ret(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_MISP_RETIRED.RETURN", level)

# Instructions per retired indirect call or jump Branch Misprediction

def IpMisp_Indirect(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("BR_MISP_RETIRED.INDIRECT", level)

# Instructions per Floating Point (FP) Operation

def IpFLOP(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("FP_FLOPS_RETIRED.ALL", level)

# Instructions per FP Arithmetic Scalar Single-Precision instruction

def IpFPArith_Scalar_SP(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("FP_INST_RETIRED.32B_SP", level)

# Instructions per FP Arithmetic Scalar Double-Precision instruction

def IpFPArith_Scalar_DP(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("FP_INST_RETIRED.64B_DP", level)

# Instructions per FP Arithmetic AVX/SSE 128-bit instruction

def IpFPArith_AVX128(self, EV, level):

return EV("INST_RETIRED.ANY", level) / (EV("FP_INST_RETIRED.128B_DP", level) + EV("FP_INST_RETIRED.128B_SP", level))

# Percentage of all uops which are microcode ops

def Microcode_Uop_Ratio(self, EV, level):

return 100 * EV("UOPS_RETIRED.MS", level) / EV("TOPDOWN_RETIRING.ALL_P", level)

# Percentage of all uops which are FPDiv uops

def FPDiv_Uop_Ratio(self, EV, level):

return 100 * EV("UOPS_RETIRED.FPDIV", level) / EV("TOPDOWN_RETIRING.ALL_P", level)

# Percentage of all uops which are IDiv uops

def IDiv_Uop_Ratio(self, EV, level):

return 100 * EV("UOPS_RETIRED.IDIV", level) / EV("TOPDOWN_RETIRING.ALL_P", level)

# Percentage of all uops which are x87 uops

def X87_Uop_Ratio(self, EV, level):

return 100 * EV("UOPS_RETIRED.X87", level) / EV("TOPDOWN_RETIRING.ALL_P", level)

# Instructions per Load

def IpLoad(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("MEM_UOPS_RETIRED.ALL_LOADS", level)

# Instructions per Store

def IpStore(self, EV, level):

return EV("INST_RETIRED.ANY", level) / EV("MEM_UOPS_RETIRED.ALL_STORES", level)

# Ratio of mem load uops to all uops

def MemLoad_Ratio(self, EV, level):

return 1000 * EV("MEM_UOPS_RETIRED.ALL_LOADS", level) / EV("TOPDOWN_RETIRING.ALL_P", level)

# Percentage of total non-speculative loads that are splits

def Load_Splits_Ratio(self, EV, level):

return 100 * EV("MEM_UOPS_RETIRED.SPLIT_LOADS", level) / EV("MEM_UOPS_RETIRED.ALL_LOADS", level)

# Percentage of total non-speculative loads that perform one or more locks

def Load_Locks_Ratio(self, EV, level):

return 100 * EV("MEM_UOPS_RETIRED.LOCK_LOADS", level) / EV("MEM_UOPS_RETIRED.ALL_LOADS", level)

# Percentage of total non-speculative loads with a store forward or unknown store address block

def PCT_Loads_with_StoreFwdBlk(self, EV, level):

return 100 * EV("LD_BLOCKS.DATA_UNKNOWN", level) / EV("MEM_UOPS_RETIRED.ALL_LOADS", level)

# Percentage of total non-speculative loads with an address aliasing block

def PCT_Loads_with_AdressAliasing(self, EV, level):

return 100 * EV("LD_BLOCKS.ADDRESS_ALIAS", level) / EV("MEM_UOPS_RETIRED.ALL_LOADS", level)

# Percentage of Memory Execution Bound due to a second level TLB miss

def PCT_LoadHead_with_STLBHit(self, EV, level):

return 100 * EV("LD_HEAD.DTLB_MISS_AT_RET", level) / EV("LD_HEAD.ANY_AT_RET", level)

# Percentage of Memory Execution Bound due to a pagewalk

def PCT_LoadHead_with_Pagewalk(self, EV, level):

return 100 * EV("LD_HEAD.PGWALK_AT_RET", level) / EV("LD_HEAD.ANY_AT_RET", level)

# Percentage of Memory Execution Bound due to a store forward address match

def PCT_LoadHead_with_StoreFwding(self, EV, level):

return 100 * EV("LD_HEAD.ST_ADDR_AT_RET", level) / EV("LD_HEAD.ANY_AT_RET", level)

# Percentage of Memory Execution Bound due to other block cases, such as pipeline conflicts, fences, etc

def PCT_LoadHead_with_OtherPipelineBlks(self, EV, level):

return 100 * EV("LD_HEAD.OTHER_AT_RET", level) / EV("LD_HEAD.ANY_AT_RET", level)

# Percentage of Memory Execution Bound due to a first level data cache miss

def PCT_LoadHead_with_L1miss(self, EV, level):

return 100 * EV("LD_HEAD.L1_MISS_AT_RET", level) / EV("LD_HEAD.ANY_AT_RET", level)

# Counts the number of cycles the core is stalled due to store buffer full

def Store_Bound(self, EV, level):

return 100 *(EV("MEM_SCHEDULER_BLOCK.ST_BUF", level) / EV("MEM_SCHEDULER_BLOCK.ALL", level)) * (EV("TOPDOWN_BE_BOUND.MEM_SCHEDULER", level) / SLOTS(self, EV, level))

# Counts the number of cycles that the oldest load of the load buffer is stalled at retirement

def Load_Bound(self, EV, level):

return 100 *(EV("LD_HEAD.L1_BOUND_AT_RET", level) + EV("MEM_BOUND_STALLS_LOAD.ALL", level)) / CLKS(self, EV, level)

# Counts the number of cycles that the oldest load of the load buffer is stalled at retirement due to a pipeline block

def L1_Bound(self, EV, level):

return 100 * EV("LD_HEAD.L1_BOUND_AT_RET", level) / CLKS(self, EV, level)

# Percentage of memory bound stalls where retirement is stalled due to an L1 miss that hit the L2

def PCT_LoadMissBound_with_L2Hit(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_LOAD.L2_HIT", level) / EV("MEM_BOUND_STALLS_LOAD.ALL", level)

# Percentage of memory bound stalls where retirement is stalled due to an L1 miss that subsequently misses in the L2

def PCT_LoadMissBound_with_L2Miss(self, EV, level):

return 100 *(EV("MEM_BOUND_STALLS_LOAD.LLC_HIT", level) + EV("MEM_BOUND_STALLS_LOAD.LLC_MISS", level)) / EV("MEM_BOUND_STALLS_LOAD.ALL", level)

# Percentage of memory bound stalls where retirement is stalled due to an L1 miss that hit the L3

def PCT_LoadMissBound_with_L3Hit(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_LOAD.LLC_HIT", level) / EV("MEM_BOUND_STALLS_LOAD.ALL", level)

# Percentage of memory bound stalls where retirement is stalled due to an L1 miss that subsequently misses the L3

def PCT_LoadMissBound_with_L3Miss(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_LOAD.LLC_MISS", level) / EV("MEM_BOUND_STALLS_LOAD.ALL", level)

# Percentage of ifetch miss bound stalls, where the ifetch miss hits in the L2

def PCT_IfetchMissBound_with_L2Hit(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_IFETCH.L2_HIT", level) / EV("MEM_BOUND_STALLS_IFETCH.ALL", level)

# Percentage of ifetch miss bound stalls, where the ifetch miss doesn't hit in the L2

def PCT_IfetchMissBound_with_L2Miss(self, EV, level):

return 100 *(EV("MEM_BOUND_STALLS_IFETCH.LLC_HIT", level) + EV("MEM_BOUND_STALLS_IFETCH.LLC_MISS", level)) / EV("MEM_BOUND_STALLS_IFETCH.ALL", level)

# Percentage of ifetch miss bound stalls, where the ifetch miss hits in the L3

def PCT_IfetchMissBound_with_L3Hit(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_IFETCH.LLC_HIT", level) / EV("MEM_BOUND_STALLS_IFETCH.ALL", level)

# Percentage of ifetch miss bound stalls, where the ifetch miss subsequently misses in the L3

def PCT_IfetchMissBound_with_L3Miss(self, EV, level):

return 100 * EV("MEM_BOUND_STALLS_IFETCH.LLC_MISS", level) / EV("MEM_BOUND_STALLS_IFETCH.ALL", level)

# Ratio of all branches which mispredict

def Branch_Mispredict_Ratio(self, EV, level):

return EV("BR_MISP_RETIRED.ALL_BRANCHES", level) / EV("BR_INST_RETIRED.ALL_BRANCHES", level)

# Ratio between Mispredicted branches and unknown branches

def Branch_Mispredict_to_Unknown_Branch_Ratio(self, EV, level):

return EV("BR_MISP_RETIRED.ALL_BRANCHES", level) / EV("BACLEARS.ANY", level)

# Counts the number of machine clears relative to thousands of instructions retired, due to floating point assists

def Machine_Clears_FP_Assist_PKI(self, EV, level):

return 1000 * EV("MACHINE_CLEARS.FP_ASSIST", level) / EV("INST_RETIRED.ANY", level)

# Counts the number of machine clears relative to thousands of instructions retired, due to page faults

def Machine_Clears_Page_Fault_PKI(self, EV, level):

return 1000 * EV("MACHINE_CLEARS.PAGE_FAULT", level) / EV("INST_RETIRED.ANY", level)

# Counts the number of machine clears relative to thousands of instructions retired, due to self-modifying code

def Machine_Clears_SMC_PKI(self, EV, level):

return 1000 * EV("MACHINE_CLEARS.SMC", level) / EV("INST_RETIRED.ANY", level)

# Percentage of time that allocation is stalled due to store buffer full

def PCT_Store_Buffer_Stall_Cycles(self, EV, level):

return 100 * EV("MEM_SCHEDULER_BLOCK.ST_BUF", level) / CLKS(self, EV, level)

# Percentage of time that allocation is stalled due to load buffer full

def PCT_Load_Buffer_Stall_Cycles(self, EV, level):

return 100 * EV("MEM_SCHEDULER_BLOCK.LD_BUF", level) / CLKS(self, EV, level)

# Percentage of time that allocation is stalled due to memory reservation stations full

def PCT_Mem_RSV_Stall_Cycles(self, EV, level):

return 100 * EV("MEM_SCHEDULER_BLOCK.RSV", level) / CLKS(self, EV, level)

# Percentage of time that the core is stalled due to a TPAUSE or UMWAIT instruction

def PCT_Tpause_Cycles(self, EV, level):

return 100 * EV("SERIALIZATION.C01_MS_SCB", level) / SLOTS(self, EV, level)

# Average Frequency Utilization relative nominal frequency

def Turbo_Utilization(self, EV, level):

return CLKS(self, EV, level) / EV("CPU_CLK_UNHALTED.REF_TSC", level)

# Fraction of cycles spent in Kernel mode

def Kernel_Utilization(self, EV, level):

return EV("CPU_CLK_UNHALTED.CORE_P:sup", level) / CLKS(self, EV, level)

# Average CPU Utilization

def CPU_Utilization(self, EV, level):

return EV("CPU_CLK_UNHALTED.REF_TSC", level) / EV("msr/tsc/", 0)

# Giga Floating Point Operations Per Second. Aggregate across all supported options of: FP precisions, scalar and vector instructions, vector-width

def GFLOPs(self, EV, level):

return EV("FP_FLOPS_RETIRED.ALL", level) / (EV("interval-s", 0) * 1000000000 )

# Event groups

class Frontend_Bound:

the backend due to frontend stalls."""

class IFetch_Latency:

limitations."""

class ICache_Misses:

the frontend due to instruction cache misses."""

class ITLB_Misses:

(ITLB) misses."""

class Branch_Detect:

branches."""

class Branch_Resteer:

Target Buffer (BTB) predicts a taken branch."""

class IFetch_Bandwidth:

decode, predecode, cisc, and other limitations."""

class Cisc:

the frontend due to the microcode sequencer (MS)."""

class Decode:

the frontend due to decode stalls."""

class Predecode:

the frontend due to wrong predecodes."""

class Other_FB:

categorized."""

class Bad_Speculation:

they were younger than the mispredict or machine clear."""

class Branch_Mispredicts:

the backend due to branch mispredicts"""

class Machine_Clears:

and memory disambiguation"""

class Nuke:

microcode (slow nuke)"""

class Fast_Nuke:

ordering, memory disambiguation and memory renaming"""

class Backend_Bound:

this event will not count"""

class Core_Bound:

outstanding load or stores, or resource limitation"""

class Allocation_Restriction:

the backend due to certain allocation restrictions"""

class Resource_Bound:

resource limitation"""

class Mem_Scheduler:

scheduler is not able to accept uops"""

class Non_Mem_Scheduler:

floating point or SIMD scheduler is not able to accept uops"""

class Register:

accept an entry (marble stalls)"""

class Reorder_Buffer:

stalls)"""

class Serialization:

(IQ), jump execution unit (JEU), or microcode sequencer (MS)"""

class Retiring:

slots"""

class Metric_PCT_Mem_Exec_Bound_Cycles:

Cluster due to a pipeline stall. See Info.Mem_Exec_Bound"""

class Metric_PCT_Load_Miss_Bound_Cycles:

miss. See Info.Load_Miss_Bound"""

class Metric_PCT_DTLB_Miss_Bound_Cycles:

level data TLB miss"""

class Metric_PCT_IFetch_Miss_Bound_Cycles: