Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quelle  core.c   Sprache: C

 
// SPDX-License-Identifier: GPL-2.0-only
/*
 * Per core/cpu state
 *
 * Used to coordinate shared registers between HT threads or
 * among events on a single PMU.
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/stddef.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/export.h>
#include <linux/nmi.h>
#include <linux/kvm_host.h>

#include <asm/cpufeature.h>
#include <asm/debugreg.h>
#include <asm/hardirq.h>
#include <asm/intel-family.h>
#include <asm/intel_pt.h>
#include <asm/apic.h>
#include <asm/cpu_device_id.h>
#include <asm/msr.h>

#include "../perf_event.h"

/*
 * Intel PerfMon, used on Core and later.
 */

static u64 intel_perfmon_event_map[PERF_COUNT_HW_MAX] __read_mostly =
{
 [PERF_COUNT_HW_CPU_CYCLES]  = 0x003c,
 [PERF_COUNT_HW_INSTRUCTIONS]  = 0x00c0,
 [PERF_COUNT_HW_CACHE_REFERENCES] = 0x4f2e,
 [PERF_COUNT_HW_CACHE_MISSES]  = 0x412e,
 [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = 0x00c4,
 [PERF_COUNT_HW_BRANCH_MISSES]  = 0x00c5,
 [PERF_COUNT_HW_BUS_CYCLES]  = 0x013c,
 [PERF_COUNT_HW_REF_CPU_CYCLES]  = 0x0300, /* pseudo-encoding */
};

static struct event_constraint intel_core_event_constraints[] __read_mostly =
{
 INTEL_EVENT_CONSTRAINT(0x11, 0x2), /* FP_ASSIST */
 INTEL_EVENT_CONSTRAINT(0x12, 0x2), /* MUL */
 INTEL_EVENT_CONSTRAINT(0x13, 0x2), /* DIV */
 INTEL_EVENT_CONSTRAINT(0x14, 0x1), /* CYCLES_DIV_BUSY */
 INTEL_EVENT_CONSTRAINT(0x19, 0x2), /* DELAYED_BYPASS */
 INTEL_EVENT_CONSTRAINT(0xc1, 0x1), /* FP_COMP_INSTR_RET */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_core2_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_EVENT_CONSTRAINT(0x10, 0x1), /* FP_COMP_OPS_EXE */
 INTEL_EVENT_CONSTRAINT(0x11, 0x2), /* FP_ASSIST */
 INTEL_EVENT_CONSTRAINT(0x12, 0x2), /* MUL */
 INTEL_EVENT_CONSTRAINT(0x13, 0x2), /* DIV */
 INTEL_EVENT_CONSTRAINT(0x14, 0x1), /* CYCLES_DIV_BUSY */
 INTEL_EVENT_CONSTRAINT(0x18, 0x1), /* IDLE_DURING_DIV */
 INTEL_EVENT_CONSTRAINT(0x19, 0x2), /* DELAYED_BYPASS */
 INTEL_EVENT_CONSTRAINT(0xa1, 0x1), /* RS_UOPS_DISPATCH_CYCLES */
 INTEL_EVENT_CONSTRAINT(0xc9, 0x1), /* ITLB_MISS_RETIRED (T30-9) */
 INTEL_EVENT_CONSTRAINT(0xcb, 0x1), /* MEM_LOAD_RETIRED */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_nehalem_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_EVENT_CONSTRAINT(0x40, 0x3), /* L1D_CACHE_LD */
 INTEL_EVENT_CONSTRAINT(0x41, 0x3), /* L1D_CACHE_ST */
 INTEL_EVENT_CONSTRAINT(0x42, 0x3), /* L1D_CACHE_LOCK */
 INTEL_EVENT_CONSTRAINT(0x43, 0x3), /* L1D_ALL_REF */
 INTEL_EVENT_CONSTRAINT(0x48, 0x3), /* L1D_PEND_MISS */
 INTEL_EVENT_CONSTRAINT(0x4e, 0x3), /* L1D_PREFETCH */
 INTEL_EVENT_CONSTRAINT(0x51, 0x3), /* L1D */
 INTEL_EVENT_CONSTRAINT(0x63, 0x3), /* CACHE_LOCK_CYCLES */
 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_nehalem_extra_regs[] __read_mostly =
{
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0xffff, RSP_0),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x100b),
 EVENT_EXTRA_END
};

static struct event_constraint intel_westmere_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_EVENT_CONSTRAINT(0x51, 0x3), /* L1D */
 INTEL_EVENT_CONSTRAINT(0x60, 0x1), /* OFFCORE_REQUESTS_OUTSTANDING */
 INTEL_EVENT_CONSTRAINT(0x63, 0x3), /* CACHE_LOCK_CYCLES */
 INTEL_EVENT_CONSTRAINT(0xb3, 0x1), /* SNOOPQ_REQUEST_OUTSTANDING */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_snb_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_UEVENT_CONSTRAINT(0x04a3, 0xf), /* CYCLE_ACTIVITY.CYCLES_NO_DISPATCH */
 INTEL_UEVENT_CONSTRAINT(0x05a3, 0xf), /* CYCLE_ACTIVITY.STALLS_L2_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x02a3, 0x4), /* CYCLE_ACTIVITY.CYCLES_L1D_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x06a3, 0x4), /* CYCLE_ACTIVITY.STALLS_L1D_PENDING */
 INTEL_EVENT_CONSTRAINT(0x48, 0x4), /* L1D_PEND_MISS.PENDING */
 INTEL_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PREC_DIST */
 INTEL_EVENT_CONSTRAINT(0xcd, 0x8), /* MEM_TRANS_RETIRED.LOAD_LATENCY */
 INTEL_UEVENT_CONSTRAINT(0x04a3, 0xf), /* CYCLE_ACTIVITY.CYCLES_NO_DISPATCH */
 INTEL_UEVENT_CONSTRAINT(0x02a3, 0x4), /* CYCLE_ACTIVITY.CYCLES_L1D_PENDING */

 /*
 * When HT is off these events can only run on the bottom 4 counters
 * When HT is on, they are impacted by the HT bug and require EXCL access
 */

 INTEL_EXCLEVT_CONSTRAINT(0xd0, 0xf), /* MEM_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd1, 0xf), /* MEM_LOAD_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd2, 0xf), /* MEM_LOAD_UOPS_LLC_HIT_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd3, 0xf), /* MEM_LOAD_UOPS_LLC_MISS_RETIRED.* */

 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_ivb_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_UEVENT_CONSTRAINT(0x0148, 0x4), /* L1D_PEND_MISS.PENDING */
 INTEL_UEVENT_CONSTRAINT(0x0279, 0xf), /* IDQ.EMPTY */
 INTEL_UEVENT_CONSTRAINT(0x019c, 0xf), /* IDQ_UOPS_NOT_DELIVERED.CORE */
 INTEL_UEVENT_CONSTRAINT(0x02a3, 0xf), /* CYCLE_ACTIVITY.CYCLES_LDM_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x04a3, 0xf), /* CYCLE_ACTIVITY.CYCLES_NO_EXECUTE */
 INTEL_UEVENT_CONSTRAINT(0x05a3, 0xf), /* CYCLE_ACTIVITY.STALLS_L2_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x06a3, 0xf), /* CYCLE_ACTIVITY.STALLS_LDM_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x08a3, 0x4), /* CYCLE_ACTIVITY.CYCLES_L1D_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x0ca3, 0x4), /* CYCLE_ACTIVITY.STALLS_L1D_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PREC_DIST */

 /*
 * When HT is off these events can only run on the bottom 4 counters
 * When HT is on, they are impacted by the HT bug and require EXCL access
 */

 INTEL_EXCLEVT_CONSTRAINT(0xd0, 0xf), /* MEM_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd1, 0xf), /* MEM_LOAD_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd2, 0xf), /* MEM_LOAD_UOPS_LLC_HIT_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd3, 0xf), /* MEM_LOAD_UOPS_LLC_MISS_RETIRED.* */

 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_westmere_extra_regs[] __read_mostly =
{
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0xffff, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x01bb, MSR_OFFCORE_RSP_1, 0xffff, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x100b),
 EVENT_EXTRA_END
};

static struct event_constraint intel_v1_event_constraints[] __read_mostly =
{
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_gen_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_v5_gen_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x0400, 3), /* SLOTS */
 FIXED_EVENT_CONSTRAINT(0x0500, 4),
 FIXED_EVENT_CONSTRAINT(0x0600, 5),
 FIXED_EVENT_CONSTRAINT(0x0700, 6),
 FIXED_EVENT_CONSTRAINT(0x0800, 7),
 FIXED_EVENT_CONSTRAINT(0x0900, 8),
 FIXED_EVENT_CONSTRAINT(0x0a00, 9),
 FIXED_EVENT_CONSTRAINT(0x0b00, 10),
 FIXED_EVENT_CONSTRAINT(0x0c00, 11),
 FIXED_EVENT_CONSTRAINT(0x0d00, 12),
 FIXED_EVENT_CONSTRAINT(0x0e00, 13),
 FIXED_EVENT_CONSTRAINT(0x0f00, 14),
 FIXED_EVENT_CONSTRAINT(0x1000, 15),
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_slm_event_constraints[] __read_mostly =
{
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* pseudo CPU_CLK_UNHALTED.REF */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_grt_event_constraints[] __read_mostly = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* pseudo CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x013c, 2), /* CPU_CLK_UNHALTED.REF_TSC_P */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_skt_event_constraints[] __read_mostly = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* pseudo CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x013c, 2), /* CPU_CLK_UNHALTED.REF_TSC_P */
 FIXED_EVENT_CONSTRAINT(0x0073, 4), /* TOPDOWN_BAD_SPECULATION.ALL */
 FIXED_EVENT_CONSTRAINT(0x019c, 5), /* TOPDOWN_FE_BOUND.ALL */
 FIXED_EVENT_CONSTRAINT(0x02c2, 6), /* TOPDOWN_RETIRING.ALL */
 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_skl_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_UEVENT_CONSTRAINT(0x1c0, 0x2), /* INST_RETIRED.PREC_DIST */

 /*
 * when HT is off, these can only run on the bottom 4 counters
 */

 INTEL_EVENT_CONSTRAINT(0xd0, 0xf), /* MEM_INST_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xd1, 0xf), /* MEM_LOAD_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xd2, 0xf), /* MEM_LOAD_L3_HIT_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xcd, 0xf), /* MEM_TRANS_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xc6, 0xf), /* FRONTEND_RETIRED.* */

 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_knl_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x799ffbb6e7ull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x02b7, MSR_OFFCORE_RSP_1, 0x399ffbffe7ull, RSP_1),
 EVENT_EXTRA_END
};

static struct extra_reg intel_snb_extra_regs[] __read_mostly = {
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x3f807f8fffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x01bb, MSR_OFFCORE_RSP_1, 0x3f807f8fffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 EVENT_EXTRA_END
};

static struct extra_reg intel_snbep_extra_regs[] __read_mostly = {
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x3fffff8fffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x01bb, MSR_OFFCORE_RSP_1, 0x3fffff8fffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 EVENT_EXTRA_END
};

static struct extra_reg intel_skl_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x3fffff8fffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x01bb, MSR_OFFCORE_RSP_1, 0x3fffff8fffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 /*
 * Note the low 8 bits eventsel code is not a continuous field, containing
 * some #GPing bits. These are masked out.
 */

 INTEL_UEVENT_EXTRA_REG(0x01c6, MSR_PEBS_FRONTEND, 0x7fff17, FE),
 EVENT_EXTRA_END
};

static struct event_constraint intel_icl_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x01c0, 0), /* old INST_RETIRED.PREC_DIST */
 FIXED_EVENT_CONSTRAINT(0x0100, 0), /* INST_RETIRED.PREC_DIST */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x0400, 3), /* SLOTS */
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_RETIRING, 0),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BAD_SPEC, 1),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_FE_BOUND, 2),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BE_BOUND, 3),
 INTEL_EVENT_CONSTRAINT_RANGE(0x03, 0x0a, 0xf),
 INTEL_EVENT_CONSTRAINT_RANGE(0x1f, 0x28, 0xf),
 INTEL_EVENT_CONSTRAINT(0x32, 0xf), /* SW_PREFETCH_ACCESS.* */
 INTEL_EVENT_CONSTRAINT_RANGE(0x48, 0x56, 0xf),
 INTEL_EVENT_CONSTRAINT_RANGE(0x60, 0x8b, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x04a3, 0xff),  /* CYCLE_ACTIVITY.STALLS_TOTAL */
 INTEL_UEVENT_CONSTRAINT(0x10a3, 0xff),  /* CYCLE_ACTIVITY.CYCLES_MEM_ANY */
 INTEL_UEVENT_CONSTRAINT(0x14a3, 0xff),  /* CYCLE_ACTIVITY.STALLS_MEM_ANY */
 INTEL_EVENT_CONSTRAINT(0xa3, 0xf),      /* CYCLE_ACTIVITY.* */
 INTEL_EVENT_CONSTRAINT_RANGE(0xa8, 0xb0, 0xf),
 INTEL_EVENT_CONSTRAINT_RANGE(0xb7, 0xbd, 0xf),
 INTEL_EVENT_CONSTRAINT_RANGE(0xd0, 0xe6, 0xf),
 INTEL_EVENT_CONSTRAINT(0xef, 0xf),
 INTEL_EVENT_CONSTRAINT_RANGE(0xf0, 0xf4, 0xf),
 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_icl_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x3fffffbfffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x01bb, MSR_OFFCORE_RSP_1, 0x3fffffbfffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 INTEL_UEVENT_EXTRA_REG(0x01c6, MSR_PEBS_FRONTEND, 0x7fff17, FE),
 EVENT_EXTRA_END
};

static struct extra_reg intel_glc_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x012a, MSR_OFFCORE_RSP_0, 0x3fffffffffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x012b, MSR_OFFCORE_RSP_1, 0x3fffffffffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 INTEL_UEVENT_EXTRA_REG(0x01c6, MSR_PEBS_FRONTEND, 0x7fff1f, FE),
 INTEL_UEVENT_EXTRA_REG(0x40ad, MSR_PEBS_FRONTEND, 0x7, FE),
 INTEL_UEVENT_EXTRA_REG(0x04c2, MSR_PEBS_FRONTEND, 0x8, FE),
 EVENT_EXTRA_END
};

static struct event_constraint intel_glc_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x0100, 0), /* INST_RETIRED.PREC_DIST */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x013c, 2), /* CPU_CLK_UNHALTED.REF_TSC_P */
 FIXED_EVENT_CONSTRAINT(0x0400, 3), /* SLOTS */
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_RETIRING, 0),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BAD_SPEC, 1),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_FE_BOUND, 2),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BE_BOUND, 3),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_HEAVY_OPS, 4),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BR_MISPREDICT, 5),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_FETCH_LAT, 6),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_MEM_BOUND, 7),

 INTEL_EVENT_CONSTRAINT(0x2e, 0xff),
 INTEL_EVENT_CONSTRAINT(0x3c, 0xff),
 /*
 * Generally event codes < 0x90 are restricted to counters 0-3.
 * The 0x2E and 0x3C are exception, which has no restriction.
 */

 INTEL_EVENT_CONSTRAINT_RANGE(0x01, 0x8f, 0xf),

 INTEL_UEVENT_CONSTRAINT(0x01a3, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x02a3, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x08a3, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x04a4, 0x1),
 INTEL_UEVENT_CONSTRAINT(0x08a4, 0x1),
 INTEL_UEVENT_CONSTRAINT(0x02cd, 0x1),
 INTEL_EVENT_CONSTRAINT(0xce, 0x1),
 INTEL_EVENT_CONSTRAINT_RANGE(0xd0, 0xdf, 0xf),
 /*
 * Generally event codes >= 0x90 are likely to have no restrictions.
 * The exception are defined as above.
 */

 INTEL_EVENT_CONSTRAINT_RANGE(0x90, 0xfe, 0xff),

 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_rwc_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x012a, MSR_OFFCORE_RSP_0, 0x3fffffffffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x012b, MSR_OFFCORE_RSP_1, 0x3fffffffffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 INTEL_UEVENT_EXTRA_REG(0x02c6, MSR_PEBS_FRONTEND, 0x9, FE),
 INTEL_UEVENT_EXTRA_REG(0x03c6, MSR_PEBS_FRONTEND, 0x7fff1f, FE),
 INTEL_UEVENT_EXTRA_REG(0x40ad, MSR_PEBS_FRONTEND, 0x7, FE),
 INTEL_UEVENT_EXTRA_REG(0x04c2, MSR_PEBS_FRONTEND, 0x8, FE),
 EVENT_EXTRA_END
};

static struct event_constraint intel_lnc_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x0100, 0), /* INST_RETIRED.PREC_DIST */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 FIXED_EVENT_CONSTRAINT(0x013c, 2), /* CPU_CLK_UNHALTED.REF_TSC_P */
 FIXED_EVENT_CONSTRAINT(0x0400, 3), /* SLOTS */
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_RETIRING, 0),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BAD_SPEC, 1),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_FE_BOUND, 2),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BE_BOUND, 3),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_HEAVY_OPS, 4),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_BR_MISPREDICT, 5),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_FETCH_LAT, 6),
 METRIC_EVENT_CONSTRAINT(INTEL_TD_METRIC_MEM_BOUND, 7),

 INTEL_EVENT_CONSTRAINT(0x20, 0xf),

 INTEL_UEVENT_CONSTRAINT(0x012a, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x012b, 0xf),
 INTEL_UEVENT_CONSTRAINT(0x0148, 0x4),
 INTEL_UEVENT_CONSTRAINT(0x0175, 0x4),

 INTEL_EVENT_CONSTRAINT(0x2e, 0x3ff),
 INTEL_EVENT_CONSTRAINT(0x3c, 0x3ff),

 INTEL_UEVENT_CONSTRAINT(0x08a3, 0x4),
 INTEL_UEVENT_CONSTRAINT(0x0ca3, 0x4),
 INTEL_UEVENT_CONSTRAINT(0x04a4, 0x1),
 INTEL_UEVENT_CONSTRAINT(0x08a4, 0x1),
 INTEL_UEVENT_CONSTRAINT(0x10a4, 0x1),
 INTEL_UEVENT_CONSTRAINT(0x01b1, 0x8),
 INTEL_UEVENT_CONSTRAINT(0x01cd, 0x3fc),
 INTEL_UEVENT_CONSTRAINT(0x02cd, 0x3),

 INTEL_EVENT_CONSTRAINT_RANGE(0xd0, 0xdf, 0xf),

 INTEL_UEVENT_CONSTRAINT(0x00e0, 0xf),

 EVENT_CONSTRAINT_END
};

static struct extra_reg intel_lnc_extra_regs[] __read_mostly = {
 INTEL_UEVENT_EXTRA_REG(0x012a, MSR_OFFCORE_RSP_0, 0xfffffffffffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x012b, MSR_OFFCORE_RSP_1, 0xfffffffffffull, RSP_1),
 INTEL_UEVENT_PEBS_LDLAT_EXTRA_REG(0x01cd),
 INTEL_UEVENT_EXTRA_REG(0x02c6, MSR_PEBS_FRONTEND, 0x9, FE),
 INTEL_UEVENT_EXTRA_REG(0x03c6, MSR_PEBS_FRONTEND, 0x7fff1f, FE),
 INTEL_UEVENT_EXTRA_REG(0x40ad, MSR_PEBS_FRONTEND, 0xf, FE),
 INTEL_UEVENT_EXTRA_REG(0x04c2, MSR_PEBS_FRONTEND, 0x8, FE),
 EVENT_EXTRA_END
};

EVENT_ATTR_STR(mem-loads, mem_ld_nhm, "event=0x0b,umask=0x10,ldlat=3");
EVENT_ATTR_STR(mem-loads, mem_ld_snb, "event=0xcd,umask=0x1,ldlat=3");
EVENT_ATTR_STR(mem-stores, mem_st_snb, "event=0xcd,umask=0x2");

static struct attribute *nhm_mem_events_attrs[] = {
 EVENT_PTR(mem_ld_nhm),
 NULL,
};

/*
 * topdown events for Intel Core CPUs.
 *
 * The events are all in slots, which is a free slot in a 4 wide
 * pipeline. Some events are already reported in slots, for cycle
 * events we multiply by the pipeline width (4).
 *
 * With Hyper Threading on, topdown metrics are either summed or averaged
 * between the threads of a core: (count_t0 + count_t1).
 *
 * For the average case the metric is always scaled to pipeline width,
 * so we use factor 2 ((count_t0 + count_t1) / 2 * 4)
 */


EVENT_ATTR_STR_HT(topdown-total-slots, td_total_slots,
 "event=0x3c,umask=0x0",   /* cpu_clk_unhalted.thread */
 "event=0x3c,umask=0x0,any=1");  /* cpu_clk_unhalted.thread_any */
EVENT_ATTR_STR_HT(topdown-total-slots.scale, td_total_slots_scale, "4""2");
EVENT_ATTR_STR(topdown-slots-issued, td_slots_issued,
 "event=0xe,umask=0x1");   /* uops_issued.any */
EVENT_ATTR_STR(topdown-slots-retired, td_slots_retired,
 "event=0xc2,umask=0x2");  /* uops_retired.retire_slots */
EVENT_ATTR_STR(topdown-fetch-bubbles, td_fetch_bubbles,
 "event=0x9c,umask=0x1");  /* idq_uops_not_delivered_core */
EVENT_ATTR_STR_HT(topdown-recovery-bubbles, td_recovery_bubbles,
 "event=0xd,umask=0x3,cmask=1",  /* int_misc.recovery_cycles */
 "event=0xd,umask=0x3,cmask=1,any=1"); /* int_misc.recovery_cycles_any */
EVENT_ATTR_STR_HT(topdown-recovery-bubbles.scale, td_recovery_bubbles_scale,
 "4""2");

EVENT_ATTR_STR(slots,   slots,   "event=0x00,umask=0x4");
EVENT_ATTR_STR(topdown-retiring, td_retiring,  "event=0x00,umask=0x80");
EVENT_ATTR_STR(topdown-bad-spec, td_bad_spec,  "event=0x00,umask=0x81");
EVENT_ATTR_STR(topdown-fe-bound, td_fe_bound,  "event=0x00,umask=0x82");
EVENT_ATTR_STR(topdown-be-bound, td_be_bound,  "event=0x00,umask=0x83");
EVENT_ATTR_STR(topdown-heavy-ops, td_heavy_ops,  "event=0x00,umask=0x84");
EVENT_ATTR_STR(topdown-br-mispredict, td_br_mispredict, "event=0x00,umask=0x85");
EVENT_ATTR_STR(topdown-fetch-lat, td_fetch_lat,  "event=0x00,umask=0x86");
EVENT_ATTR_STR(topdown-mem-bound, td_mem_bound,  "event=0x00,umask=0x87");

static struct attribute *snb_events_attrs[] = {
 EVENT_PTR(td_slots_issued),
 EVENT_PTR(td_slots_retired),
 EVENT_PTR(td_fetch_bubbles),
 EVENT_PTR(td_total_slots),
 EVENT_PTR(td_total_slots_scale),
 EVENT_PTR(td_recovery_bubbles),
 EVENT_PTR(td_recovery_bubbles_scale),
 NULL,
};

static struct attribute *snb_mem_events_attrs[] = {
 EVENT_PTR(mem_ld_snb),
 EVENT_PTR(mem_st_snb),
 NULL,
};

static struct event_constraint intel_hsw_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_UEVENT_CONSTRAINT(0x148, 0x4), /* L1D_PEND_MISS.PENDING */
 INTEL_UEVENT_CONSTRAINT(0x01c0, 0x2), /* INST_RETIRED.PREC_DIST */
 INTEL_EVENT_CONSTRAINT(0xcd, 0x8), /* MEM_TRANS_RETIRED.LOAD_LATENCY */
 /* CYCLE_ACTIVITY.CYCLES_L1D_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x08a3, 0x4),
 /* CYCLE_ACTIVITY.STALLS_L1D_PENDING */
 INTEL_UEVENT_CONSTRAINT(0x0ca3, 0x4),
 /* CYCLE_ACTIVITY.CYCLES_NO_EXECUTE */
 INTEL_UEVENT_CONSTRAINT(0x04a3, 0xf),

 /*
 * When HT is off these events can only run on the bottom 4 counters
 * When HT is on, they are impacted by the HT bug and require EXCL access
 */

 INTEL_EXCLEVT_CONSTRAINT(0xd0, 0xf), /* MEM_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd1, 0xf), /* MEM_LOAD_UOPS_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd2, 0xf), /* MEM_LOAD_UOPS_LLC_HIT_RETIRED.* */
 INTEL_EXCLEVT_CONSTRAINT(0xd3, 0xf), /* MEM_LOAD_UOPS_LLC_MISS_RETIRED.* */

 EVENT_CONSTRAINT_END
};

static struct event_constraint intel_bdw_event_constraints[] = {
 FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
 FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
 FIXED_EVENT_CONSTRAINT(0x0300, 2), /* CPU_CLK_UNHALTED.REF */
 INTEL_UEVENT_CONSTRAINT(0x148, 0x4), /* L1D_PEND_MISS.PENDING */
 INTEL_UBIT_EVENT_CONSTRAINT(0x8a3, 0x4), /* CYCLE_ACTIVITY.CYCLES_L1D_MISS */
 /*
 * when HT is off, these can only run on the bottom 4 counters
 */

 INTEL_EVENT_CONSTRAINT(0xd0, 0xf), /* MEM_INST_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xd1, 0xf), /* MEM_LOAD_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xd2, 0xf), /* MEM_LOAD_L3_HIT_RETIRED.* */
 INTEL_EVENT_CONSTRAINT(0xcd, 0xf), /* MEM_TRANS_RETIRED.* */
 EVENT_CONSTRAINT_END
};

static u64 intel_pmu_event_map(int hw_event)
{
 return intel_perfmon_event_map[hw_event];
}

static __initconst const u64 glc_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0,
  [ C(RESULT_MISS)   ] = 0xe124,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_MISS)   ] = 0xe424,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x12a,
  [ C(RESULT_MISS)   ] = 0x12a,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x12a,
  [ C(RESULT_MISS)   ] = 0x12a,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0,
  [ C(RESULT_MISS)   ] = 0xe12,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0,
  [ C(RESULT_MISS)   ] = 0xe13,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = 0xe11,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x4c4,
  [ C(RESULT_MISS)   ] = 0x4c5,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x12a,
  [ C(RESULT_MISS)   ] = 0x12a,
 },
 },
};

static __initconst const u64 glc_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x10001,
  [ C(RESULT_MISS)   ] = 0x3fbfc00001,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x3f3ffc0002,
  [ C(RESULT_MISS)   ] = 0x3f3fc00002,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x10c000001,
  [ C(RESULT_MISS)   ] = 0x3fb3000001,
 },
 },
};

/*
 * Notes on the events:
 * - data reads do not include code reads (comparable to earlier tables)
 * - data counts include speculative execution (except L1 write, dtlb, bpu)
 * - remote node access includes remote memory, remote cache, remote mmio.
 * - prefetches are not included in the counts.
 * - icache miss does not include decoded icache
 */


#define SKL_DEMAND_DATA_RD  BIT_ULL(0)
#define SKL_DEMAND_RFO   BIT_ULL(1)
#define SKL_ANY_RESPONSE  BIT_ULL(16)
#define SKL_SUPPLIER_NONE  BIT_ULL(17)
#define SKL_L3_MISS_LOCAL_DRAM  BIT_ULL(26)
#define SKL_L3_MISS_REMOTE_HOP0_DRAM BIT_ULL(27)
#define SKL_L3_MISS_REMOTE_HOP1_DRAM BIT_ULL(28)
#define SKL_L3_MISS_REMOTE_HOP2P_DRAM BIT_ULL(29)
#define SKL_L3_MISS   (SKL_L3_MISS_LOCAL_DRAM| \
      SKL_L3_MISS_REMOTE_HOP0_DRAM| \
      SKL_L3_MISS_REMOTE_HOP1_DRAM| \
      SKL_L3_MISS_REMOTE_HOP2P_DRAM)
#define SKL_SPL_HIT   BIT_ULL(30)
#define SKL_SNOOP_NONE   BIT_ULL(31)
#define SKL_SNOOP_NOT_NEEDED  BIT_ULL(32)
#define SKL_SNOOP_MISS   BIT_ULL(33)
#define SKL_SNOOP_HIT_NO_FWD  BIT_ULL(34)
#define SKL_SNOOP_HIT_WITH_FWD  BIT_ULL(35)
#define SKL_SNOOP_HITM   BIT_ULL(36)
#define SKL_SNOOP_NON_DRAM  BIT_ULL(37)
#define SKL_ANY_SNOOP   (SKL_SPL_HIT|SKL_SNOOP_NONE| \
      SKL_SNOOP_NOT_NEEDED|SKL_SNOOP_MISS| \
      SKL_SNOOP_HIT_NO_FWD|SKL_SNOOP_HIT_WITH_FWD| \
      SKL_SNOOP_HITM|SKL_SNOOP_NON_DRAM)
#define SKL_DEMAND_READ   SKL_DEMAND_DATA_RD
#define SKL_SNOOP_DRAM   (SKL_SNOOP_NONE| \
      SKL_SNOOP_NOT_NEEDED|SKL_SNOOP_MISS| \
      SKL_SNOOP_HIT_NO_FWD|SKL_SNOOP_HIT_WITH_FWD| \
      SKL_SNOOP_HITM|SKL_SPL_HIT)
#define SKL_DEMAND_WRITE  SKL_DEMAND_RFO
#define SKL_LLC_ACCESS   SKL_ANY_RESPONSE
#define SKL_L3_MISS_REMOTE  (SKL_L3_MISS_REMOTE_HOP0_DRAM| \
      SKL_L3_MISS_REMOTE_HOP1_DRAM| \
      SKL_L3_MISS_REMOTE_HOP2P_DRAM)

static __initconst const u64 skl_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_INST_RETIRED.ALL_LOADS */
  [ C(RESULT_MISS)   ] = 0x151, /* L1D.REPLACEMENT */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_INST_RETIRED.ALL_STORES */
  [ C(RESULT_MISS)   ] = 0x0,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x283, /* ICACHE_64B.MISS */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_INST_RETIRED.ALL_LOADS */
  [ C(RESULT_MISS)   ] = 0xe08, /* DTLB_LOAD_MISSES.WALK_COMPLETED */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_INST_RETIRED.ALL_STORES */
  [ C(RESULT_MISS)   ] = 0xe49, /* DTLB_STORE_MISSES.WALK_COMPLETED */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x2085, /* ITLB_MISSES.STLB_HIT */
  [ C(RESULT_MISS)   ] = 0xe85, /* ITLB_MISSES.WALK_COMPLETED */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0xc4, /* BR_INST_RETIRED.ALL_BRANCHES */
  [ C(RESULT_MISS)   ] = 0xc5, /* BR_MISP_RETIRED.ALL_BRANCHES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
};

static __initconst const u64 skl_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = SKL_DEMAND_READ|
           SKL_LLC_ACCESS|SKL_ANY_SNOOP,
  [ C(RESULT_MISS)   ] = SKL_DEMAND_READ|
           SKL_L3_MISS|SKL_ANY_SNOOP|
           SKL_SUPPLIER_NONE,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = SKL_DEMAND_WRITE|
           SKL_LLC_ACCESS|SKL_ANY_SNOOP,
  [ C(RESULT_MISS)   ] = SKL_DEMAND_WRITE|
           SKL_L3_MISS|SKL_ANY_SNOOP|
           SKL_SUPPLIER_NONE,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = SKL_DEMAND_READ|
           SKL_L3_MISS_LOCAL_DRAM|SKL_SNOOP_DRAM,
  [ C(RESULT_MISS)   ] = SKL_DEMAND_READ|
           SKL_L3_MISS_REMOTE|SKL_SNOOP_DRAM,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = SKL_DEMAND_WRITE|
           SKL_L3_MISS_LOCAL_DRAM|SKL_SNOOP_DRAM,
  [ C(RESULT_MISS)   ] = SKL_DEMAND_WRITE|
           SKL_L3_MISS_REMOTE|SKL_SNOOP_DRAM,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
};

#define SNB_DMND_DATA_RD (1ULL << 0)
#define SNB_DMND_RFO  (1ULL << 1)
#define SNB_DMND_IFETCH  (1ULL << 2)
#define SNB_DMND_WB  (1ULL << 3)
#define SNB_PF_DATA_RD  (1ULL << 4)
#define SNB_PF_RFO  (1ULL << 5)
#define SNB_PF_IFETCH  (1ULL << 6)
#define SNB_LLC_DATA_RD  (1ULL << 7)
#define SNB_LLC_RFO  (1ULL << 8)
#define SNB_LLC_IFETCH  (1ULL << 9)
#define SNB_BUS_LOCKS  (1ULL << 10)
#define SNB_STRM_ST  (1ULL << 11)
#define SNB_OTHER  (1ULL << 15)
#define SNB_RESP_ANY  (1ULL << 16)
#define SNB_NO_SUPP  (1ULL << 17)
#define SNB_LLC_HITM  (1ULL << 18)
#define SNB_LLC_HITE  (1ULL << 19)
#define SNB_LLC_HITS  (1ULL << 20)
#define SNB_LLC_HITF  (1ULL << 21)
#define SNB_LOCAL  (1ULL << 22)
#define SNB_REMOTE  (0xffULL << 23)
#define SNB_SNP_NONE  (1ULL << 31)
#define SNB_SNP_NOT_NEEDED (1ULL << 32)
#define SNB_SNP_MISS  (1ULL << 33)
#define SNB_NO_FWD  (1ULL << 34)
#define SNB_SNP_FWD  (1ULL << 35)
#define SNB_HITM  (1ULL << 36)
#define SNB_NON_DRAM  (1ULL << 37)

#define SNB_DMND_READ  (SNB_DMND_DATA_RD|SNB_LLC_DATA_RD)
#define SNB_DMND_WRITE  (SNB_DMND_RFO|SNB_LLC_RFO)
#define SNB_DMND_PREFETCH (SNB_PF_DATA_RD|SNB_PF_RFO)

#define SNB_SNP_ANY  (SNB_SNP_NONE|SNB_SNP_NOT_NEEDED| \
     SNB_SNP_MISS|SNB_NO_FWD|SNB_SNP_FWD| \
     SNB_HITM)

#define SNB_DRAM_ANY  (SNB_LOCAL|SNB_REMOTE|SNB_SNP_ANY)
#define SNB_DRAM_REMOTE  (SNB_REMOTE|SNB_SNP_ANY)

#define SNB_L3_ACCESS  SNB_RESP_ANY
#define SNB_L3_MISS  (SNB_DRAM_ANY|SNB_NON_DRAM)

static __initconst const u64 snb_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_READ|SNB_L3_ACCESS,
  [ C(RESULT_MISS)   ] = SNB_DMND_READ|SNB_L3_MISS,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_WRITE|SNB_L3_ACCESS,
  [ C(RESULT_MISS)   ] = SNB_DMND_WRITE|SNB_L3_MISS,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_PREFETCH|SNB_L3_ACCESS,
  [ C(RESULT_MISS)   ] = SNB_DMND_PREFETCH|SNB_L3_MISS,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_READ|SNB_DRAM_ANY,
  [ C(RESULT_MISS)   ] = SNB_DMND_READ|SNB_DRAM_REMOTE,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_WRITE|SNB_DRAM_ANY,
  [ C(RESULT_MISS)   ] = SNB_DMND_WRITE|SNB_DRAM_REMOTE,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = SNB_DMND_PREFETCH|SNB_DRAM_ANY,
  [ C(RESULT_MISS)   ] = SNB_DMND_PREFETCH|SNB_DRAM_REMOTE,
 },
 },
};

static __initconst const u64 snb_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0xf1d0, /* MEM_UOP_RETIRED.LOADS        */
  [ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPLACEMENT              */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0xf2d0, /* MEM_UOP_RETIRED.STORES       */
  [ C(RESULT_MISS)   ] = 0x0851, /* L1D.ALL_M_REPLACEMENT        */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x024e, /* HW_PRE_REQ.DL1_MISS          */
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0280, /* ICACHE.MISSES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  /* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_WRITE) ] = {
  /* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  /* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_UOP_RETIRED.ALL_LOADS */
  [ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.CAUSES_A_WALK */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_UOP_RETIRED.ALL_STORES */
  [ C(RESULT_MISS)   ] = 0x0149, /* DTLB_STORE_MISSES.MISS_CAUSES_A_WALK */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x1085, /* ITLB_MISSES.STLB_HIT         */
  [ C(RESULT_MISS)   ] = 0x0185, /* ITLB_MISSES.CAUSES_A_WALK    */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
  [ C(RESULT_MISS)   ] = 0x00c5, /* BR_MISP_RETIRED.ALL_BRANCHES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },

};

/*
 * Notes on the events:
 * - data reads do not include code reads (comparable to earlier tables)
 * - data counts include speculative execution (except L1 write, dtlb, bpu)
 * - remote node access includes remote memory, remote cache, remote mmio.
 * - prefetches are not included in the counts because they are not
 *   reliably counted.
 */


#define HSW_DEMAND_DATA_RD  BIT_ULL(0)
#define HSW_DEMAND_RFO   BIT_ULL(1)
#define HSW_ANY_RESPONSE  BIT_ULL(16)
#define HSW_SUPPLIER_NONE  BIT_ULL(17)
#define HSW_L3_MISS_LOCAL_DRAM  BIT_ULL(22)
#define HSW_L3_MISS_REMOTE_HOP0  BIT_ULL(27)
#define HSW_L3_MISS_REMOTE_HOP1  BIT_ULL(28)
#define HSW_L3_MISS_REMOTE_HOP2P BIT_ULL(29)
#define HSW_L3_MISS   (HSW_L3_MISS_LOCAL_DRAM| \
      HSW_L3_MISS_REMOTE_HOP0|HSW_L3_MISS_REMOTE_HOP1| \
      HSW_L3_MISS_REMOTE_HOP2P)
#define HSW_SNOOP_NONE   BIT_ULL(31)
#define HSW_SNOOP_NOT_NEEDED  BIT_ULL(32)
#define HSW_SNOOP_MISS   BIT_ULL(33)
#define HSW_SNOOP_HIT_NO_FWD  BIT_ULL(34)
#define HSW_SNOOP_HIT_WITH_FWD  BIT_ULL(35)
#define HSW_SNOOP_HITM   BIT_ULL(36)
#define HSW_SNOOP_NON_DRAM  BIT_ULL(37)
#define HSW_ANY_SNOOP   (HSW_SNOOP_NONE| \
      HSW_SNOOP_NOT_NEEDED|HSW_SNOOP_MISS| \
      HSW_SNOOP_HIT_NO_FWD|HSW_SNOOP_HIT_WITH_FWD| \
      HSW_SNOOP_HITM|HSW_SNOOP_NON_DRAM)
#define HSW_SNOOP_DRAM   (HSW_ANY_SNOOP & ~HSW_SNOOP_NON_DRAM)
#define HSW_DEMAND_READ   HSW_DEMAND_DATA_RD
#define HSW_DEMAND_WRITE  HSW_DEMAND_RFO
#define HSW_L3_MISS_REMOTE  (HSW_L3_MISS_REMOTE_HOP0|\
      HSW_L3_MISS_REMOTE_HOP1|HSW_L3_MISS_REMOTE_HOP2P)
#define HSW_LLC_ACCESS   HSW_ANY_RESPONSE

#define BDW_L3_MISS_LOCAL  BIT(26)
#define BDW_L3_MISS   (BDW_L3_MISS_LOCAL| \
      HSW_L3_MISS_REMOTE_HOP0|HSW_L3_MISS_REMOTE_HOP1| \
      HSW_L3_MISS_REMOTE_HOP2P)


static __initconst const u64 hsw_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
  [ C(RESULT_MISS)   ] = 0x151, /* L1D.REPLACEMENT */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
  [ C(RESULT_MISS)   ] = 0x0,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x280, /* ICACHE.MISSES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
  [ C(RESULT_MISS)   ] = 0x108, /* DTLB_LOAD_MISSES.MISS_CAUSES_A_WALK */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
  [ C(RESULT_MISS)   ] = 0x149, /* DTLB_STORE_MISSES.MISS_CAUSES_A_WALK */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x6085, /* ITLB_MISSES.STLB_HIT */
  [ C(RESULT_MISS)   ] = 0x185, /* ITLB_MISSES.MISS_CAUSES_A_WALK */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0xc4, /* BR_INST_RETIRED.ALL_BRANCHES */
  [ C(RESULT_MISS)   ] = 0xc5, /* BR_MISP_RETIRED.ALL_BRANCHES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x1b7, /* OFFCORE_RESPONSE */
  [ C(RESULT_MISS)   ] = 0x1b7, /* OFFCORE_RESPONSE */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
};

static __initconst const u64 hsw_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = HSW_DEMAND_READ|
           HSW_LLC_ACCESS,
  [ C(RESULT_MISS)   ] = HSW_DEMAND_READ|
           HSW_L3_MISS|HSW_ANY_SNOOP,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = HSW_DEMAND_WRITE|
           HSW_LLC_ACCESS,
  [ C(RESULT_MISS)   ] = HSW_DEMAND_WRITE|
           HSW_L3_MISS|HSW_ANY_SNOOP,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = HSW_DEMAND_READ|
           HSW_L3_MISS_LOCAL_DRAM|
           HSW_SNOOP_DRAM,
  [ C(RESULT_MISS)   ] = HSW_DEMAND_READ|
           HSW_L3_MISS_REMOTE|
           HSW_SNOOP_DRAM,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = HSW_DEMAND_WRITE|
           HSW_L3_MISS_LOCAL_DRAM|
           HSW_SNOOP_DRAM,
  [ C(RESULT_MISS)   ] = HSW_DEMAND_WRITE|
           HSW_L3_MISS_REMOTE|
           HSW_SNOOP_DRAM,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
};

static __initconst const u64 westmere_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
  [ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPL                     */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
  [ C(RESULT_MISS)   ] = 0x0251, /* L1D.M_REPL                   */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x014e, /* L1D_PREFETCH.REQUESTS        */
  [ C(RESULT_MISS)   ] = 0x024e, /* L1D_PREFETCH.MISS            */
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                    */
  [ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                   */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  /* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 /*
 * Use RFO, not WRITEBACK, because a write miss would typically occur
 * on RFO.
 */

 [ C(OP_WRITE) ] = {
  /* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  /* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
  [ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.ANY         */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
  [ C(RESULT_MISS)   ] = 0x010c, /* MEM_STORE_RETIRED.DTLB_MISS  */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x01c0, /* INST_RETIRED.ANY_P           */
  [ C(RESULT_MISS)   ] = 0x0185, /* ITLB_MISSES.ANY              */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
  [ C(RESULT_MISS)   ] = 0x03e8, /* BPU_CLEARS.ANY               */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
};

/*
 * Nehalem/Westmere MSR_OFFCORE_RESPONSE bits;
 * See IA32 SDM Vol 3B 30.6.1.3
 */


#define NHM_DMND_DATA_RD (1 << 0)
#define NHM_DMND_RFO  (1 << 1)
#define NHM_DMND_IFETCH  (1 << 2)
#define NHM_DMND_WB  (1 << 3)
#define NHM_PF_DATA_RD  (1 << 4)
#define NHM_PF_DATA_RFO  (1 << 5)
#define NHM_PF_IFETCH  (1 << 6)
#define NHM_OFFCORE_OTHER (1 << 7)
#define NHM_UNCORE_HIT  (1 << 8)
#define NHM_OTHER_CORE_HIT_SNP (1 << 9)
#define NHM_OTHER_CORE_HITM (1 << 10)
           /* reserved */
#define NHM_REMOTE_CACHE_FWD (1 << 12)
#define NHM_REMOTE_DRAM  (1 << 13)
#define NHM_LOCAL_DRAM  (1 << 14)
#define NHM_NON_DRAM  (1 << 15)

#define NHM_LOCAL  (NHM_LOCAL_DRAM|NHM_REMOTE_CACHE_FWD)
#define NHM_REMOTE  (NHM_REMOTE_DRAM)

#define NHM_DMND_READ  (NHM_DMND_DATA_RD)
#define NHM_DMND_WRITE  (NHM_DMND_RFO|NHM_DMND_WB)
#define NHM_DMND_PREFETCH (NHM_PF_DATA_RD|NHM_PF_DATA_RFO)

#define NHM_L3_HIT (NHM_UNCORE_HIT|NHM_OTHER_CORE_HIT_SNP|NHM_OTHER_CORE_HITM)
#define NHM_L3_MISS (NHM_NON_DRAM|NHM_LOCAL_DRAM|NHM_REMOTE_DRAM|NHM_REMOTE_CACHE_FWD)
#define NHM_L3_ACCESS (NHM_L3_HIT|NHM_L3_MISS)

static __initconst const u64 nehalem_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_READ|NHM_L3_ACCESS,
  [ C(RESULT_MISS)   ] = NHM_DMND_READ|NHM_L3_MISS,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_WRITE|NHM_L3_ACCESS,
  [ C(RESULT_MISS)   ] = NHM_DMND_WRITE|NHM_L3_MISS,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_PREFETCH|NHM_L3_ACCESS,
  [ C(RESULT_MISS)   ] = NHM_DMND_PREFETCH|NHM_L3_MISS,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_READ|NHM_LOCAL|NHM_REMOTE,
  [ C(RESULT_MISS)   ] = NHM_DMND_READ|NHM_REMOTE,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_WRITE|NHM_LOCAL|NHM_REMOTE,
  [ C(RESULT_MISS)   ] = NHM_DMND_WRITE|NHM_REMOTE,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = NHM_DMND_PREFETCH|NHM_LOCAL|NHM_REMOTE,
  [ C(RESULT_MISS)   ] = NHM_DMND_PREFETCH|NHM_REMOTE,
 },
 },
};

static __initconst const u64 nehalem_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x010b, /* MEM_INST_RETIRED.LOADS       */
  [ C(RESULT_MISS)   ] = 0x0151, /* L1D.REPL                     */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x020b, /* MEM_INST_RETURED.STORES      */
  [ C(RESULT_MISS)   ] = 0x0251, /* L1D.M_REPL                   */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x014e, /* L1D_PREFETCH.REQUESTS        */
  [ C(RESULT_MISS)   ] = 0x024e, /* L1D_PREFETCH.MISS            */
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                    */
  [ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                   */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  /* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_DATA.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 /*
 * Use RFO, not WRITEBACK, because a write miss would typically occur
 * on RFO.
 */

 [ C(OP_WRITE) ] = {
  /* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  /* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI   (alias)  */
  [ C(RESULT_MISS)   ] = 0x0108, /* DTLB_LOAD_MISSES.ANY         */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI   (alias)  */
  [ C(RESULT_MISS)   ] = 0x010c, /* MEM_STORE_RETIRED.DTLB_MISS  */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0x0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x01c0, /* INST_RETIRED.ANY_P           */
  [ C(RESULT_MISS)   ] = 0x20c8, /* ITLB_MISS_RETIRED            */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
  [ C(RESULT_MISS)   ] = 0x03e8, /* BPU_CLEARS.ANY               */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(NODE) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
};

static __initconst const u64 core2_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI          */
  [ C(RESULT_MISS)   ] = 0x0140, /* L1D_CACHE_LD.I_STATE       */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI          */
  [ C(RESULT_MISS)   ] = 0x0141, /* L1D_CACHE_ST.I_STATE       */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x104e, /* L1D_PREFETCH.REQUESTS      */
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0080, /* L1I.READS                  */
  [ C(RESULT_MISS)   ] = 0x0081, /* L1I.MISSES                 */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x4f29, /* L2_LD.MESI                 */
  [ C(RESULT_MISS)   ] = 0x4129, /* L2_LD.ISTATE               */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x4f2A, /* L2_ST.MESI                 */
  [ C(RESULT_MISS)   ] = 0x412A, /* L2_ST.ISTATE               */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f40, /* L1D_CACHE_LD.MESI  (alias) */
  [ C(RESULT_MISS)   ] = 0x0208, /* DTLB_MISSES.MISS_LD        */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x0f41, /* L1D_CACHE_ST.MESI  (alias) */
  [ C(RESULT_MISS)   ] = 0x0808, /* DTLB_MISSES.MISS_ST        */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c0, /* INST_RETIRED.ANY_P         */
  [ C(RESULT_MISS)   ] = 0x1282, /* ITLBMISSES                 */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ANY        */
  [ C(RESULT_MISS)   ] = 0x00c5, /* BP_INST_RETIRED.MISPRED    */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
};

static __initconst const u64 atom_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x2140, /* L1D_CACHE.LD               */
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x2240, /* L1D_CACHE.ST               */
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0x0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0380, /* L1I.READS                  */
  [ C(RESULT_MISS)   ] = 0x0280, /* L1I.MISSES                 */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x4f29, /* L2_LD.MESI                 */
  [ C(RESULT_MISS)   ] = 0x4129, /* L2_LD.ISTATE               */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x4f2A, /* L2_ST.MESI                 */
  [ C(RESULT_MISS)   ] = 0x412A, /* L2_ST.ISTATE               */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x2140, /* L1D_CACHE_LD.MESI  (alias) */
  [ C(RESULT_MISS)   ] = 0x0508, /* DTLB_MISSES.MISS_LD        */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0x2240, /* L1D_CACHE_ST.MESI  (alias) */
  [ C(RESULT_MISS)   ] = 0x0608, /* DTLB_MISSES.MISS_ST        */
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c0, /* INST_RETIRED.ANY_P         */
  [ C(RESULT_MISS)   ] = 0x0282, /* ITLB.MISSES                */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ANY        */
  [ C(RESULT_MISS)   ] = 0x00c5, /* BP_INST_RETIRED.MISPRED    */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
};

EVENT_ATTR_STR(topdown-total-slots, td_total_slots_slm, "event=0x3c");
EVENT_ATTR_STR(topdown-total-slots.scale, td_total_slots_scale_slm, "2");
/* no_alloc_cycles.not_delivered */
EVENT_ATTR_STR(topdown-fetch-bubbles, td_fetch_bubbles_slm,
        "event=0xca,umask=0x50");
EVENT_ATTR_STR(topdown-fetch-bubbles.scale, td_fetch_bubbles_scale_slm, "2");
/* uops_retired.all */
EVENT_ATTR_STR(topdown-slots-issued, td_slots_issued_slm,
        "event=0xc2,umask=0x10");
/* uops_retired.all */
EVENT_ATTR_STR(topdown-slots-retired, td_slots_retired_slm,
        "event=0xc2,umask=0x10");

static struct attribute *slm_events_attrs[] = {
 EVENT_PTR(td_total_slots_slm),
 EVENT_PTR(td_total_slots_scale_slm),
 EVENT_PTR(td_fetch_bubbles_slm),
 EVENT_PTR(td_fetch_bubbles_scale_slm),
 EVENT_PTR(td_slots_issued_slm),
 EVENT_PTR(td_slots_retired_slm),
 NULL
};

static struct extra_reg intel_slm_extra_regs[] __read_mostly =
{
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x768005ffffull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x02b7, MSR_OFFCORE_RSP_1, 0x368005ffffull, RSP_1),
 EVENT_EXTRA_END
};

#define SLM_DMND_READ  SNB_DMND_DATA_RD
#define SLM_DMND_WRITE  SNB_DMND_RFO
#define SLM_DMND_PREFETCH (SNB_PF_DATA_RD|SNB_PF_RFO)

#define SLM_SNP_ANY  (SNB_SNP_NONE|SNB_SNP_MISS|SNB_NO_FWD|SNB_HITM)
#define SLM_LLC_ACCESS  SNB_RESP_ANY
#define SLM_LLC_MISS  (SLM_SNP_ANY|SNB_NON_DRAM)

static __initconst const u64 slm_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = SLM_DMND_READ|SLM_LLC_ACCESS,
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = SLM_DMND_WRITE|SLM_LLC_ACCESS,
  [ C(RESULT_MISS)   ] = SLM_DMND_WRITE|SLM_LLC_MISS,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = SLM_DMND_PREFETCH|SLM_LLC_ACCESS,
  [ C(RESULT_MISS)   ] = SLM_DMND_PREFETCH|SLM_LLC_MISS,
 },
 },
};

static __initconst const u64 slm_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] =
{
 [ C(L1D) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0x0104, /* LD_DCU_MISS */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(L1I ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x0380, /* ICACHE.ACCESSES */
  [ C(RESULT_MISS)   ] = 0x0280, /* ICACGE.MISSES */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(LL  ) ] = {
 [ C(OP_READ) ] = {
  /* OFFCORE_RESPONSE.ANY_DATA.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_WRITE) ] = {
  /* OFFCORE_RESPONSE.ANY_RFO.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.ANY_RFO.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 [ C(OP_PREFETCH) ] = {
  /* OFFCORE_RESPONSE.PREFETCH.LOCAL_CACHE */
  [ C(RESULT_ACCESS) ] = 0x01b7,
  /* OFFCORE_RESPONSE.PREFETCH.ANY_LLC_MISS */
  [ C(RESULT_MISS)   ] = 0x01b7,
 },
 },
 [ C(DTLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0x0804, /* LD_DTLB_MISS */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = 0,
  [ C(RESULT_MISS)   ] = 0,
 },
 },
 [ C(ITLB) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c0, /* INST_RETIRED.ANY_P */
  [ C(RESULT_MISS)   ] = 0x40205, /* PAGE_WALKS.I_SIDE_WALKS */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
 [ C(BPU ) ] = {
 [ C(OP_READ) ] = {
  [ C(RESULT_ACCESS) ] = 0x00c4, /* BR_INST_RETIRED.ANY */
  [ C(RESULT_MISS)   ] = 0x00c5, /* BP_INST_RETIRED.MISPRED */
 },
 [ C(OP_WRITE) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 [ C(OP_PREFETCH) ] = {
  [ C(RESULT_ACCESS) ] = -1,
  [ C(RESULT_MISS)   ] = -1,
 },
 },
};

EVENT_ATTR_STR(topdown-total-slots, td_total_slots_glm, "event=0x3c");
EVENT_ATTR_STR(topdown-total-slots.scale, td_total_slots_scale_glm, "3");
/* UOPS_NOT_DELIVERED.ANY */
EVENT_ATTR_STR(topdown-fetch-bubbles, td_fetch_bubbles_glm, "event=0x9c");
/* ISSUE_SLOTS_NOT_CONSUMED.RECOVERY */
EVENT_ATTR_STR(topdown-recovery-bubbles, td_recovery_bubbles_glm, "event=0xca,umask=0x02");
/* UOPS_RETIRED.ANY */
EVENT_ATTR_STR(topdown-slots-retired, td_slots_retired_glm, "event=0xc2");
/* UOPS_ISSUED.ANY */
EVENT_ATTR_STR(topdown-slots-issued, td_slots_issued_glm, "event=0x0e");

static struct attribute *glm_events_attrs[] = {
 EVENT_PTR(td_total_slots_glm),
 EVENT_PTR(td_total_slots_scale_glm),
 EVENT_PTR(td_fetch_bubbles_glm),
 EVENT_PTR(td_recovery_bubbles_glm),
 EVENT_PTR(td_slots_issued_glm),
 EVENT_PTR(td_slots_retired_glm),
 NULL
};

static struct extra_reg intel_glm_extra_regs[] __read_mostly = {
 /* must define OFFCORE_RSP_X first, see intel_fixup_er() */
 INTEL_UEVENT_EXTRA_REG(0x01b7, MSR_OFFCORE_RSP_0, 0x760005ffbfull, RSP_0),
 INTEL_UEVENT_EXTRA_REG(0x02b7, MSR_OFFCORE_RSP_1, 0x360005ffbfull, RSP_1),
 EVENT_EXTRA_END
};

#define GLM_DEMAND_DATA_RD  BIT_ULL(0)
#define GLM_DEMAND_RFO   BIT_ULL(1)
#define GLM_ANY_RESPONSE  BIT_ULL(16)
#define GLM_SNP_NONE_OR_MISS  BIT_ULL(33)
#define GLM_DEMAND_READ   GLM_DEMAND_DATA_RD
#define GLM_DEMAND_WRITE  GLM_DEMAND_RFO
#define GLM_DEMAND_PREFETCH  (SNB_PF_DATA_RD|SNB_PF_RFO)
#define GLM_LLC_ACCESS   GLM_ANY_RESPONSE
#define GLM_SNP_ANY   (GLM_SNP_NONE_OR_MISS|SNB_NO_FWD|SNB_HITM)
#define GLM_LLC_MISS   (GLM_SNP_ANY|SNB_NON_DRAM)

static __initconst const u64 glm_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
 [C(L1D)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(L1I)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x0380, /* ICACHE.ACCESSES */
   [C(RESULT_MISS)] = 0x0280, /* ICACHE.MISSES */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(LL)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x1b7, /* OFFCORE_RESPONSE */
   [C(RESULT_MISS)] = 0x1b7, /* OFFCORE_RESPONSE */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x1b7, /* OFFCORE_RESPONSE */
   [C(RESULT_MISS)] = 0x1b7, /* OFFCORE_RESPONSE */
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x1b7, /* OFFCORE_RESPONSE */
   [C(RESULT_MISS)] = 0x1b7, /* OFFCORE_RESPONSE */
  },
 },
 [C(DTLB)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(ITLB)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x00c0, /* INST_RETIRED.ANY_P */
   [C(RESULT_MISS)] = 0x0481, /* ITLB.MISS */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
 },
 [C(BPU)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x00c4, /* BR_INST_RETIRED.ALL_BRANCHES */
   [C(RESULT_MISS)] = 0x00c5, /* BR_MISP_RETIRED.ALL_BRANCHES */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
 },
};

static __initconst const u64 glm_hw_cache_extra_regs
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
 [C(LL)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = GLM_DEMAND_READ|
        GLM_LLC_ACCESS,
   [C(RESULT_MISS)] = GLM_DEMAND_READ|
        GLM_LLC_MISS,
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = GLM_DEMAND_WRITE|
        GLM_LLC_ACCESS,
   [C(RESULT_MISS)] = GLM_DEMAND_WRITE|
        GLM_LLC_MISS,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = GLM_DEMAND_PREFETCH|
        GLM_LLC_ACCESS,
   [C(RESULT_MISS)] = GLM_DEMAND_PREFETCH|
        GLM_LLC_MISS,
  },
 },
};

static __initconst const u64 glp_hw_cache_event_ids
    [PERF_COUNT_HW_CACHE_MAX]
    [PERF_COUNT_HW_CACHE_OP_MAX]
    [PERF_COUNT_HW_CACHE_RESULT_MAX] = {
 [C(L1D)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
   [C(RESULT_MISS)] = 0x0,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(L1I)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x0380, /* ICACHE.ACCESSES */
   [C(RESULT_MISS)] = 0x0280, /* ICACHE.MISSES */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = -1,
   [C(RESULT_MISS)] = -1,
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(LL)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x1b7, /* OFFCORE_RESPONSE */
   [C(RESULT_MISS)] = 0x1b7, /* OFFCORE_RESPONSE */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x1b7, /* OFFCORE_RESPONSE */
   [C(RESULT_MISS)] = 0x1b7, /* OFFCORE_RESPONSE */
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(DTLB)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x81d0, /* MEM_UOPS_RETIRED.ALL_LOADS */
   [C(RESULT_MISS)] = 0xe08, /* DTLB_LOAD_MISSES.WALK_COMPLETED */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = 0x82d0, /* MEM_UOPS_RETIRED.ALL_STORES */
   [C(RESULT_MISS)] = 0xe49, /* DTLB_STORE_MISSES.WALK_COMPLETED */
  },
  [C(OP_PREFETCH)] = {
   [C(RESULT_ACCESS)] = 0x0,
   [C(RESULT_MISS)] = 0x0,
  },
 },
 [C(ITLB)] = {
  [C(OP_READ)] = {
   [C(RESULT_ACCESS)] = 0x00c0, /* INST_RETIRED.ANY_P */
   [C(RESULT_MISS)] = 0x0481, /* ITLB.MISS */
  },
  [C(OP_WRITE)] = {
   [C(RESULT_ACCESS)] = -1,
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=92 H=91 G=91

¤ Dauer der Verarbeitung: 0.33 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge