Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932384AbbLQUCO (ORCPT ); Thu, 17 Dec 2015 15:02:14 -0500 Received: from mga11.intel.com ([192.55.52.93]:12302 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755176AbbLQTr0 (ORCPT ); Thu, 17 Dec 2015 14:47:26 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.20,442,1444719600"; d="scan'208";a="873743737" From: "Fenghua Yu" To: "H. Peter Anvin" , "Ingo Molnar" , "Thomas Gleixner" , "Tony Luck" , "Ravi V Shankar" , "Peter Zijlstra" , "Tejun Heo" , "Marcelo Tosatti" Cc: "linux-kernel" , "x86" , Fenghua Yu , Vikas Shivappa Subject: [PATCH V16 07/11] x86/intel_rdt: Implement scheduling support for Intel RDT Date: Thu, 17 Dec 2015 14:46:12 -0800 Message-Id: <1450392376-6397-8-git-send-email-fenghua.yu@intel.com> X-Mailer: git-send-email 1.8.0.1 In-Reply-To: <1450392376-6397-1-git-send-email-fenghua.yu@intel.com> References: <1450392376-6397-1-git-send-email-fenghua.yu@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 8966 Lines: 283 From: Fenghua Yu From: Vikas Shivappa Adds support for IA32_PQR_ASSOC MSR writes during task scheduling. For Cache Allocation, MSR write would let the task fill in the cache 'subset' represented by the task's capacity bit mask. The high 32 bits in the per processor MSR IA32_PQR_ASSOC represents the CLOSid. During context switch kernel implements this by writing the CLOSid of the task belongs to the CPU's IA32_PQR_ASSOC MSR. This patch also implements a common software cache for IA32_PQR_MSR (RMID 0:9, CLOSId 32:63) to be used by both Cache monitoring (CMT) and Cache allocation. CMT updates the RMID where as cache_alloc updates the CLOSid in the software cache. During scheduling when the new RMID/CLOSid value is different from the cached values, IA32_PQR_MSR is updated. Since the measured rdmsr latency for IA32_PQR_MSR is very high (~250 cycles) this software cache is necessary to avoid reading the MSR to compare the current CLOSid value. The following considerations are done for the PQR MSR write so that it minimally impacts scheduler hot path: - This path does not exist on any non-intel platforms. - On Intel platforms, this would not exist by default unless INTEL_RDT is enabled. - remains a no-op when INTEL_RDT is enabled and intel SKU does not support the feature. - When feature is available and enabled, never does MSR write till the user manually starts using one of the capacity bit masks. - MSR write is only done when there is a task with different Closid is scheduled on the CPU. Typically if the task groups are bound to be scheduled on a set of CPUs, the number of MSR writes is greatly reduced. - A per CPU cache of CLOSids is maintained to do the check so that we don't have to do a rdmsr which actually costs a lot of cycles. Signed-off-by: Vikas Shivappa Signed-off-by: Fenghua Yu --- arch/x86/include/asm/intel_rdt.h | 28 ++++++++++++++++++++++++++++ arch/x86/include/asm/pqr_common.h | 27 +++++++++++++++++++++++++++ arch/x86/kernel/cpu/intel_rdt.c | 25 +++++++++++++++++++++++++ arch/x86/kernel/cpu/perf_event_intel_cqm.c | 26 +++----------------------- arch/x86/kernel/process_64.c | 6 ++++++ 5 files changed, 89 insertions(+), 23 deletions(-) create mode 100644 arch/x86/include/asm/pqr_common.h diff --git a/arch/x86/include/asm/intel_rdt.h b/arch/x86/include/asm/intel_rdt.h index 4f45dc8..afb6da3 100644 --- a/arch/x86/include/asm/intel_rdt.h +++ b/arch/x86/include/asm/intel_rdt.h @@ -3,14 +3,42 @@ #ifdef CONFIG_INTEL_RDT +#include + #define MAX_CBM_LENGTH 32 #define IA32_L3_CBM_BASE 0xc90 #define CBM_FROM_INDEX(x) (IA32_L3_CBM_BASE + x) +extern struct static_key rdt_enable_key; +void __intel_rdt_sched_in(void *dummy); + struct clos_cbm_table { unsigned long l3_cbm; unsigned int clos_refcnt; }; +/* + * intel_rdt_sched_in() - Writes the task's CLOSid to IA32_PQR_MSR + * + * Following considerations are made so that this has minimal impact + * on scheduler hot path: + * - This will stay as no-op unless we are running on an Intel SKU + * which supports L3 cache allocation. + * - Caches the per cpu CLOSid values and does the MSR write only + * when a task with a different CLOSid is scheduled in. + */ +static inline void intel_rdt_sched_in(void) +{ + /* + * Call the schedule in code only when RDT is enabled. + */ + if (static_key_false(&rdt_enable_key)) + __intel_rdt_sched_in(NULL); +} + +#else + +static inline void intel_rdt_sched_in(void) {} + #endif #endif diff --git a/arch/x86/include/asm/pqr_common.h b/arch/x86/include/asm/pqr_common.h new file mode 100644 index 0000000..11e985c --- /dev/null +++ b/arch/x86/include/asm/pqr_common.h @@ -0,0 +1,27 @@ +#ifndef _X86_RDT_H_ +#define _X86_RDT_H_ + +#define MSR_IA32_PQR_ASSOC 0x0c8f + +/** + * struct intel_pqr_state - State cache for the PQR MSR + * @rmid: The cached Resource Monitoring ID + * @closid: The cached Class Of Service ID + * @rmid_usecnt: The usage counter for rmid + * + * The upper 32 bits of MSR_IA32_PQR_ASSOC contain closid and the + * lower 10 bits rmid. The update to MSR_IA32_PQR_ASSOC always + * contains both parts, so we need to cache them. + * + * The cache also helps to avoid pointless updates if the value does + * not change. + */ +struct intel_pqr_state { + u32 rmid; + u32 closid; + int rmid_usecnt; +}; + +DECLARE_PER_CPU(struct intel_pqr_state, pqr_state); + +#endif diff --git a/arch/x86/kernel/cpu/intel_rdt.c b/arch/x86/kernel/cpu/intel_rdt.c index 6ad5b48..8379df8 100644 --- a/arch/x86/kernel/cpu/intel_rdt.c +++ b/arch/x86/kernel/cpu/intel_rdt.c @@ -24,6 +24,8 @@ #include #include +#include +#include #include /* @@ -44,12 +46,33 @@ static cpumask_t rdt_cpumask; */ static cpumask_t tmp_cpumask; static DEFINE_MUTEX(rdt_group_mutex); +struct static_key __read_mostly rdt_enable_key = STATIC_KEY_INIT_FALSE; struct rdt_remote_data { int msr; u64 val; }; +void __intel_rdt_sched_in(void *dummy) +{ + struct intel_pqr_state *state = this_cpu_ptr(&pqr_state); + u32 closid = current->closid; + + if (closid == state->closid) + return; + + wrmsr(MSR_IA32_PQR_ASSOC, state->rmid, closid); + state->closid = closid; +} + +/* + * Synchronize the IA32_PQR_ASSOC MSR of all currently running tasks. + */ +static inline void closid_tasks_sync(void) +{ + on_each_cpu_mask(cpu_online_mask, __intel_rdt_sched_in, NULL, 1); +} + static inline void closid_get(u32 closid) { struct clos_cbm_table *cct = &cctable[closid]; @@ -240,6 +263,8 @@ static int __init intel_rdt_late_init(void) for_each_online_cpu(i) rdt_cpumask_update(i); + + static_key_slow_inc(&rdt_enable_key); pr_info("Intel cache allocation enabled\n"); out_err: diff --git a/arch/x86/kernel/cpu/perf_event_intel_cqm.c b/arch/x86/kernel/cpu/perf_event_intel_cqm.c index dd82bc7..b05f21e 100644 --- a/arch/x86/kernel/cpu/perf_event_intel_cqm.c +++ b/arch/x86/kernel/cpu/perf_event_intel_cqm.c @@ -7,41 +7,22 @@ #include #include #include +#include #include "perf_event.h" -#define MSR_IA32_PQR_ASSOC 0x0c8f #define MSR_IA32_QM_CTR 0x0c8e #define MSR_IA32_QM_EVTSEL 0x0c8d static u32 cqm_max_rmid = -1; static unsigned int cqm_l3_scale; /* supposedly cacheline size */ -/** - * struct intel_pqr_state - State cache for the PQR MSR - * @rmid: The cached Resource Monitoring ID - * @closid: The cached Class Of Service ID - * @rmid_usecnt: The usage counter for rmid - * - * The upper 32 bits of MSR_IA32_PQR_ASSOC contain closid and the - * lower 10 bits rmid. The update to MSR_IA32_PQR_ASSOC always - * contains both parts, so we need to cache them. - * - * The cache also helps to avoid pointless updates if the value does - * not change. - */ -struct intel_pqr_state { - u32 rmid; - u32 closid; - int rmid_usecnt; -}; - /* * The cached intel_pqr_state is strictly per CPU and can never be * updated from a remote CPU. Both functions which modify the state * (intel_cqm_event_start and intel_cqm_event_stop) are called with * interrupts disabled, which is sufficient for the protection. */ -static DEFINE_PER_CPU(struct intel_pqr_state, pqr_state); +DEFINE_PER_CPU(struct intel_pqr_state, pqr_state); /* * Protects cache_cgroups and cqm_rmid_free_lru and cqm_rmid_limbo_lru. @@ -408,9 +389,9 @@ static void __intel_cqm_event_count(void *info); */ static u32 intel_cqm_xchg_rmid(struct perf_event *group, u32 rmid) { - struct perf_event *event; struct list_head *head = &group->hw.cqm_group_entry; u32 old_rmid = group->hw.cqm_rmid; + struct perf_event *event; lockdep_assert_held(&cache_mutex); @@ -1265,7 +1246,6 @@ static void intel_cqm_cpu_starting(unsigned int cpu) struct cpuinfo_x86 *c = &cpu_data(cpu); state->rmid = 0; - state->closid = 0; state->rmid_usecnt = 0; WARN_ON(c->x86_cache_max_rmid != cqm_max_rmid); diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c index e835d26..76066ec 100644 --- a/arch/x86/kernel/process_64.c +++ b/arch/x86/kernel/process_64.c @@ -48,6 +48,7 @@ #include #include #include +#include asmlinkage extern void ret_from_fork(void); @@ -439,6 +440,11 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p) loadsegment(ss, __KERNEL_DS); } + /* + * Load the Intel cache allocation PQR MSR. + */ + intel_rdt_sched_in(); + return prev_p; } -- 2.5.0 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/