X86 TLB flush optimization
Subsystems (10)
v10 cover X86 TLB flush optimization
Thank for Fengguang's 0-day build system. It found 2 build errors on the first and 7th patch.
So this version fix them, introduce a c_detect_tlb() member into struct cpu_dev for tlb entries detection of specific CPU vendor.
Thanks all of comments and testing on this patchset!
Alex
[PATCH v10 1/9] x86/tlb_info: get last level TLB entry number of CPU [PATCH v10 2/9] x86/flush_tlb: try flush_tlb_single one by one in [PATCH v10 3/9] x86/tlb: fall back to flush all when meet a THP [PATCH v10 4/9] x86/tlb: add tlb_flushall_shift for specific CPU [PATCH v10 5/9] x86/tlb: add tlb_flushall_shift knob into debugfs [PATCH v10 6/9] mm/mmu_gather: enable tlb flush range in generic [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86 [PATCH v10 8/9] x86/tlb: replace INVALIDATE_TLB_VECTOR by [PATCH v10 9/9] x86/tlb: do flush_tlb_kernel_range by 'invlpg'
PATCH v10 1/9 x86/tlb_info: get last level TLB entry number of CPU
For 4KB pages, x86 CPU has 2 or 1 level TLB, first level is data TLB and instruction TLB, second level is shared TLB for both data and instructions.
For hupe page TLB, usually there is just one level and seperated by 2MB/4MB and 1GB.
Although each levels TLB size is important for performance tuning, but for genernal and rude optimizing, last level TLB entry number is suitable. And in fact, last level TLB always has the biggest entry number.
This patch will get the biggest TLB entry number and use it in furture TLB optimizing.
Accroding Borislav's suggestion, except tlb_ll[i/d]_* array, other function and data will be released after system boot up.
For all kinds of x86 vendor friendly, vendor specific code was moved to its specific files.
--- arch/x86/include/asm/processor.h | 11 +++ arch/x86/kernel/cpu/common.c | 21 ++++++ arch/x86/kernel/cpu/cpu.h | 9 +++ arch/x86/kernel/cpu/intel.c | 142 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 183 insertions(+), 0 deletions(-)
arch/x86/include/asm/processor.h +11 -0
@@ -61,6 +61,17 @@ static inline void *current_text_addr(void)# define ARCH_MIN_MMSTRUCT_ALIGN 0#endif +enum tlb_infos { +ENTRIES , +NR_INFO +}; + +extern u16 __read_mostly tlb_lli_4k[NR_INFO ]; +extern u16 __read_mostly tlb_lli_2m[NR_INFO ]; +extern u16 __read_mostly tlb_lli_4m[NR_INFO ]; +extern u16 __read_mostly tlb_lld_4k[NR_INFO ]; +extern u16 __read_mostly tlb_lld_2m[NR_INFO ]; +extern u16 __read_mostly tlb_lld_4m[NR_INFO ];/* * CPU type and hardware bug flags. Kept separately for each CPU. * Members of this structure are referenced in head.S, so think twice
arch/x86/kernel/cpu/common.c +21 -0
@@ -452,6 +452,25 @@ void __cpuinit cpu_detect_cache_sizes(struct cpuinfo_x86 *c) c->x86_cache_size = l2size; } +u16 __read_mostly tlb_lli_4k[NR_INFO ]; +u16 __read_mostly tlb_lli_2m[NR_INFO ]; +u16 __read_mostly tlb_lli_4m[NR_INFO ]; +u16 __read_mostly tlb_lld_4k[NR_INFO ]; +u16 __read_mostly tlb_lld_2m[NR_INFO ]; +u16 __read_mostly tlb_lld_4m[NR_INFO ]; + +void __cpuinit cpu_detect_tlb (struct cpuinfo_x86 *c) +{ +if (this_cpu->c_detect_tlb) + this_cpu->c_detect_tlb (c); + +printk (KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ +"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" , + tlb_lli_4k[ENTRIES ], tlb_lli_2m[ENTRIES ], + tlb_lli_4m[ENTRIES ], tlb_lld_4k[ENTRIES ], + tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ]); +} +void __cpuinit detect_ht (struct cpuinfo_x86 *c) {#ifdef CONFIG_X86_HT
@@ -911,6 +930,8 @@ void __init identify_boot_cpu(void)#else vgetcpu_set_mode ();#endif +if (boot_cpu_data.cpuid_level >=2 ) +cpu_detect_tlb (&boot_cpu_data); }void __cpuinit identify_secondary_cpu (struct cpuinfo_x86 *c)
arch/x86/kernel/cpu/cpu.h +9 -0
@@ -20,10 +20,19 @@ struct cpu_dev {void (*c_bsp_init)(struct cpuinfo_x86 *);void (*c_init)(struct cpuinfo_x86 *);void (*c_identify)(struct cpuinfo_x86 *); +void (*c_detect_tlb)(struct cpuinfo_x86 *);unsigned int (*c_size_cache)(struct cpuinfo_x86 *,unsigned int );int c_x86_vendor; }; +struct _tlb_table { +unsigned char descriptor; +char tlb_type; +unsigned int entries; +/* unsigned int ways; */ +char info[128 ]; +}; +#define cpu_dev_register (cpu_devX) \ static const struct cpu_dev *const __cpu_dev_##cpu_devX __used \ __attribute__((__section__(".x86_cpu_dev.init"))) = \
arch/x86/kernel/cpu/intel.c +142 -0
154 lines not on this page · raw message
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb_info: get last level TLB entry number of CPU
Commit-ID: e0ba94f14f747c2661c4d21f8c44e5b0b8cd8e48 Gitweb: http://git.kernel.org/tip/e0ba94f14f747c2661c4d21f8c44e5b0b8cd8e48 Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:16 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:28:24 -0700
x86/tlb_info: get last level TLB entry number of CPU
For 4KB pages, x86 CPU has 2 or 1 level TLB, first level is data TLB and instruction TLB, second level is shared TLB for both data and instructions.
For hupe page TLB, usually there is just one level and seperated by 2MB/4MB and 1GB.
Although each levels TLB size is important for performance tuning, but for genernal and rude optimizing, last level TLB entry number is suitable. And in fact, last level TLB always has the biggest entry number.
This patch will get the biggest TLB entry number and use it in furture TLB optimizing.
Accroding Borislav's suggestion, except tlb_ll[i/d]_* array, other function and data will be released after system boot up.
For all kinds of x86 vendor friendly, vendor specific code was moved to its specific files.
--- arch/x86/include/asm/processor.h | 11 +++ arch/x86/kernel/cpu/common.c | 21 ++++++ arch/x86/kernel/cpu/cpu.h | 9 +++ arch/x86/kernel/cpu/intel.c | 142 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 183 insertions(+), 0 deletions(-)
arch/x86/include/asm/processor.h +11 -0
@@ -61,6 +61,17 @@ static inline void *current_text_addr(void)# define ARCH_MIN_MMSTRUCT_ALIGN 0#endif +enum tlb_infos { +ENTRIES , +NR_INFO +}; + +extern u16 __read_mostly tlb_lli_4k[NR_INFO ]; +extern u16 __read_mostly tlb_lli_2m[NR_INFO ]; +extern u16 __read_mostly tlb_lli_4m[NR_INFO ]; +extern u16 __read_mostly tlb_lld_4k[NR_INFO ]; +extern u16 __read_mostly tlb_lld_2m[NR_INFO ]; +extern u16 __read_mostly tlb_lld_4m[NR_INFO ];/* * CPU type and hardware bug flags. Kept separately for each CPU. * Members of this structure are referenced in head.S, so think twice
arch/x86/kernel/cpu/common.c +21 -0
@@ -452,6 +452,25 @@ void __cpuinit cpu_detect_cache_sizes(struct cpuinfo_x86 *c) c->x86_cache_size = l2size; } +u16 __read_mostly tlb_lli_4k[NR_INFO ]; +u16 __read_mostly tlb_lli_2m[NR_INFO ]; +u16 __read_mostly tlb_lli_4m[NR_INFO ]; +u16 __read_mostly tlb_lld_4k[NR_INFO ]; +u16 __read_mostly tlb_lld_2m[NR_INFO ]; +u16 __read_mostly tlb_lld_4m[NR_INFO ]; + +void __cpuinit cpu_detect_tlb (struct cpuinfo_x86 *c) +{ +if (this_cpu->c_detect_tlb) + this_cpu->c_detect_tlb (c); + +printk (KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ +"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" , + tlb_lli_4k[ENTRIES ], tlb_lli_2m[ENTRIES ], + tlb_lli_4m[ENTRIES ], tlb_lld_4k[ENTRIES ], + tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ]); +} +void __cpuinit detect_ht (struct cpuinfo_x86 *c) {#ifdef CONFIG_X86_HT
@@ -911,6 +930,8 @@ void __init identify_boot_cpu(void)#else vgetcpu_set_mode ();#endif +if (boot_cpu_data.cpuid_level >=2 ) +cpu_detect_tlb (&boot_cpu_data); }void __cpuinit identify_secondary_cpu (struct cpuinfo_x86 *c)
arch/x86/kernel/cpu/cpu.h +9 -0
@@ -20,10 +20,19 @@ struct cpu_dev {void (*c_bsp_init)(struct cpuinfo_x86 *);void (*c_init)(struct cpuinfo_x86 *);void (*c_identify)(struct cpuinfo_x86 *); +void (*c_detect_tlb)(struct cpuinfo_x86 *);unsigned int (*c_size_cache)(struct cpuinfo_x86 *,unsigned int );int c_x86_vendor; }; +struct _tlb_table { +unsigned char descriptor; +char tlb_type; +unsigned int entries; +/* unsigned int ways; */ +char info[128 ]; +}; +#define cpu_dev_register (cpu_devX) \ static const struct cpu_dev *const __cpu_dev_##cpu_devX __used \ __attribute__((__section__(".x86_cpu_dev.init"))) = \
arch/x86/kernel/cpu/intel.c +142 -0
154 lines not on this page · raw message
PATCH v10 2/9 x86/flush_tlb: try flush_tlb_single one by one in flush_tlb_range
In reply to Alex Shix86 has no flush_tlb_range support in instruction level. Currently the flush_tlb_range just implemented by flushing all page table. That is not the best solution for all scenarios. In fact, if we just use 'invlpg' to flush few lines from TLB, we can get the performance gain from later remain TLB lines accessing.
But the 'invlpg' instruction costs much of time. Its execution time can compete with cr3 rewriting, and even a bit more on SNB CPU.
So, on a 512 4KB TLB entries CPU, the balance points is at:
(512 - X) * 100ns(assumed TLB refill cost) = X(TLB flush entries) * 100ns(assumed invlpg cost)
Here, X is 256, that is 1/2 of 512 entries.
But with the mysterious CPU pre-fetcher and page miss handler Unit, the assumed TLB refill cost is far lower then 100ns in sequential access. And 2 HT siblings in one core makes the memory access more faster if they are accessing the same memory. So, in the patch, I just do the change when the target entries is less than 1/16 of whole active tlb entries. Actually, I have no data support for the percentage '1/16', so any suggestions are welcomed.
As to hugetlb, guess due to smaller page table, and smaller active TLB entries, I didn't see benefit via my benchmark, so no optimizing now.
My micro benchmark show in ideal scenarios, the performance improves 70 percent in reading. And in worst scenario, the reading/writing performance is similar with unpatched 3.4-rc4 kernel.
Here is the reading data on my 2P * 4cores *HT NHM EP machine, with THP 'always':
multi thread testing, '-t' paramter is thread number:
with patch unpatched 3.4-rc4
./mprotect -t 1 14ns 24ns ./mprotect -t 2 13ns 22ns ./mprotect -t 4 12ns 19ns ./mprotect -t 8 14ns 16ns ./mprotect -t 16 28ns 26ns ./mprotect -t 32 54ns 51ns ./mprotect -t 128 200ns 199ns
Single process with sequencial flushing and memory accessing:
with patch unpatched 3.4-rc4
./mprotect 7ns 11ns
./mprotect -p 4096 -l 8 -n 10240
21ns 21ns
--- arch/x86/include/asm/paravirt.h | 5 +- arch/x86/include/asm/paravirt_types.h | 3 +- arch/x86/include/asm/tlbflush.h | 23 +++----- arch/x86/include/asm/uv/uv.h | 5 +- arch/x86/mm/tlb.c | 97 +++++++++++++++++++++++++++------ arch/x86/platform/uv/tlb_uv.c | 6 +- arch/x86/xen/mmu.c | 12 ++-- include/trace/events/xen.h | 12 +++-- 8 files changed, 114 insertions(+), 49 deletions(-)
arch/x86/include/asm/paravirt.h +3 -2
@@ -397,9 +397,10 @@ static inline void __flush_tlb_single(unsigned long addr)static inline void flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va) +unsigned long start, +unsigned long end) { -PVOP_VCALL3 (pv_mmu_ops.flush_tlb_others, cpumask, mm, va); +PVOP_VCALL4 (pv_mmu_ops.flush_tlb_others, cpumask, mm, start, end); }static inline int paravirt_pgd_alloc (struct mm_struct *mm)
arch/x86/include/asm/paravirt_types.h +2 -1
@@ -250,7 +250,8 @@ struct pv_mmu_ops {void (*flush_tlb_single)(unsigned long addr);void (*flush_tlb_others)(const struct cpumask *cpus,struct mm_struct *mm, -unsigned long va); +unsigned long start, +unsigned long end);/* Hooks for allocating and freeing a pagetable top-level */ int (*pgd_alloc)(struct mm_struct *mm);
arch/x86/include/asm/tlbflush.h +9 -14
@@ -73,14 +73,10 @@ static inline void __flush_tlb_one(unsigned long addr)* - flush_tlb_page(vma, vmaddr) flushes one page * - flush_tlb_range(vma, start, end) flushes a range of pages * - flush_tlb_kernel_range(start, end) flushes a range of kernel pages -* - flush_tlb_others(cpumask, mm, va) flushes TLBs on other cpus +* - flush_tlb_others(cpumask, mm, start, end) flushes TLBs on other cpus * * ..but the i386 has somewhat limited tlb flushing capabilities, * and page-granular flushes are available only on i486 and up. -* -* x86-64 can only flush individual pages or full VMs. For a range flush -* we always do the full VM. Might be worth trying if for a small -* range a few INVLPGs in a row are a win. */ #ifndef CONFIG_SMP
@@ -111,7 +107,8 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,static inline void native_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va) +unsigned long start, +unsigned long end) { }
@@ -129,17 +126,14 @@ extern void flush_tlb_all(void);extern void flush_tlb_current_task (void );extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); +extern void flush_tlb_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end);#define flush_tlb () flush_tlb_current_task() -static inline void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end) -{ -flush_tlb_mm (vma->vm_mm); -} -void native_flush_tlb_others (const struct cpumask *cpumask, -struct mm_struct *mm,unsigned long va); +struct mm_struct *mm, +unsigned long start,unsigned long end);#define TLBSTATE_OK 1#define TLBSTATE_LAZY 2
@@ -159,7 +153,8 @@ static inline void reset_lazy_tlbstate(void)#endif /* SMP */ #ifndef CONFIG_PARAVIRT -#define flush_tlb_others (mask, mm, va) native_flush_tlb_others(mask, mm, va) +#define flush_tlb_others (mask, mm, start, end) \ + native_flush_tlb_others(mask, mm, start, end)#endif static inline void flush_tlb_kernel_range(unsigned long start,
arch/x86/include/asm/uv/uv.h +3 -2
@@ -15,7 +15,8 @@ extern void uv_nmi_init(void);extern void uv_system_init (void );extern const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va, +unsigned long start, +unsigned end,unsigned int cpu);#else /* X86_UV */
@@ -26,7 +27,7 @@ static inline void uv_cpu_init(void) { }static inline void uv_system_init (void ) { }static inline const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va,unsigned int cpu) +unsigned long start,unsigned long end,unsigned int cpu) {return cpumask; }#endif /* X86_UV */
arch/x86/mm/tlb.c +81 -16
168 lines not on this page · raw message
arch/x86/platform/uv/tlb_uv.c +3 -3
@@ -1068,8 +1068,8 @@ static int set_distrib_bits(struct cpumask *flush_mask, struct bau_control *bcp,* done. The returned pointer is valid till preemption is re-enabled. */ const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask, -struct mm_struct *mm,unsigned long va, -unsigned int cpu) +struct mm_struct *mm,unsigned long start, +unsigned end,unsigned int cpu) {int locals =0 ;int remotes =0 ;
@@ -1112,7 +1112,7 @@ const struct cpumask *uv_flush_tlb_others(const struct cpumask *cpumask,record_send_statistics (stat, locals, hubs, remotes, bau_desc); - bau_desc->payload.address = va; + bau_desc->payload.address = start; bau_desc->payload.sending_cpu = cpu;/* * uv_flush_send_and_wait returns 0 if all cpu's were messaged,
arch/x86/xen/mmu.c +6 -6
@@ -1244,7 +1244,8 @@ static void xen_flush_tlb_single(unsigned long addr) }static void xen_flush_tlb_others (const struct cpumask *cpus, -struct mm_struct *mm,unsigned long va) +struct mm_struct *mm,unsigned long start, +unsigned long end) {struct {struct mmuext_op op;
@@ -1256,7 +1257,7 @@ static void xen_flush_tlb_others(const struct cpumask *cpus, } *args;struct multicall_space mcs; -trace_xen_mmu_flush_tlb_others (cpus, mm, va); +trace_xen_mmu_flush_tlb_others (cpus, mm, start, end);if (cpumask_empty (cpus))return ;/* nothing to do */
@@ -1269,11 +1270,10 @@ static void xen_flush_tlb_others(const struct cpumask *cpus,cpumask_and (to_cpumask (args->mask), cpus, cpu_online_mask);cpumask_clear_cpu (smp_processor_id (),to_cpumask (args->mask)); -if (va ==TLB_FLUSH_ALL ) { - args->op.cmd =MMUEXT_TLB_FLUSH_MULTI ; - }else { + args->op.cmd =MMUEXT_TLB_FLUSH_MULTI ; +if (start !=TLB_FLUSH_ALL && (end - start) <=PAGE_SIZE ) { args->op.cmd =MMUEXT_INVLPG_MULTI ; - args->op.arg1.linear_addr = va; + args->op.arg1.linear_addr = start; }MULTI_mmuext_op (mcs.mc, &args->op,1 ,NULL ,DOMID_SELF );
include/trace/events/xen.h +7 -5
@@ -397,18 +397,20 @@ TRACE_EVENT(xen_mmu_flush_tlb_single,TRACE_EVENT (xen_mmu_flush_tlb_others, TP_PROTO(const struct cpumask *cpus, struct mm_struct *mm, - unsigned long addr), -TP_ARGS (cpus, mm, addr), + unsigned long addr, unsigned long end), +TP_ARGS (cpus, mm, addr, end),TP_STRUCT__entry ( __field(unsigned, ncpus) __field(struct mm_struct *, mm) __field(unsigned long, addr) + __field(unsigned long, end) ), TP_fast_assign(__entry->ncpus = cpumask_weight(cpus); __entry->mm = mm; - __entry->addr = addr), -TP_printk ("ncpus %d mm %p addr %lx" , - __entry->ncpus, __entry->mm, __entry->addr) + __entry->addr = addr, + __entry->end = end), +TP_printk ("ncpus %d mm %p addr %lx, end %lx" , + __entry->ncpus, __entry->mm, __entry->addr, __entry->end) ); TRACE_EVENT(xen_mmu_write_cr3,
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/flush_tlb: try flush_tlb_single one by one in flush_tlb_range
Commit-ID: e7b52ffd45a6d834473f43b349e7d86593d763c7 Gitweb: http://git.kernel.org/tip/e7b52ffd45a6d834473f43b349e7d86593d763c7 Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:17 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:07 -0700
x86/flush_tlb: try flush_tlb_single one by one in flush_tlb_range
x86 has no flush_tlb_range support in instruction level. Currently the flush_tlb_range just implemented by flushing all page table. That is not the best solution for all scenarios. In fact, if we just use 'invlpg' to flush few lines from TLB, we can get the performance gain from later remain TLB lines accessing.
But the 'invlpg' instruction costs much of time. Its execution time can compete with cr3 rewriting, and even a bit more on SNB CPU.
So, on a 512 4KB TLB entries CPU, the balance points is at:
(512 - X) * 100ns(assumed TLB refill cost) = X(TLB flush entries) * 100ns(assumed invlpg cost)
Here, X is 256, that is 1/2 of 512 entries.
But with the mysterious CPU pre-fetcher and page miss handler Unit, the assumed TLB refill cost is far lower then 100ns in sequential access. And 2 HT siblings in one core makes the memory access more faster if they are accessing the same memory. So, in the patch, I just do the change when the target entries is less than 1/16 of whole active tlb entries. Actually, I have no data support for the percentage '1/16', so any suggestions are welcomed.
As to hugetlb, guess due to smaller page table, and smaller active TLB entries, I didn't see benefit via my benchmark, so no optimizing now.
My micro benchmark show in ideal scenarios, the performance improves 70 percent in reading. And in worst scenario, the reading/writing performance is similar with unpatched 3.4-rc4 kernel.
Here is the reading data on my 2P * 4cores *HT NHM EP machine, with THP 'always':
multi thread testing, '-t' paramter is thread number:
with patch unpatched 3.4-rc4
./mprotect -t 1 14ns 24ns ./mprotect -t 2 13ns 22ns ./mprotect -t 4 12ns 19ns ./mprotect -t 8 14ns 16ns ./mprotect -t 16 28ns 26ns ./mprotect -t 32 54ns 51ns ./mprotect -t 128 200ns 199ns
Single process with sequencial flushing and memory accessing:
with patch unpatched 3.4-rc4
./mprotect 7ns 11ns
./mprotect -p 4096 -l 8 -n 10240
21ns 21ns
[ hpa: http://lkml.kernel.org/r/1B4B44D9196EFF41AE41FDA404FC0A100BFF94@SHSMSX101.ccr.corp.intel.com
has additional performance numbers. ]
--- arch/x86/include/asm/paravirt.h | 5 +- arch/x86/include/asm/paravirt_types.h | 3 +- arch/x86/include/asm/tlbflush.h | 23 +++----- arch/x86/include/asm/uv/uv.h | 5 +- arch/x86/mm/tlb.c | 97 +++++++++++++++++++++++++++------ arch/x86/platform/uv/tlb_uv.c | 6 +- arch/x86/xen/mmu.c | 12 ++-- include/trace/events/xen.h | 12 +++-- 8 files changed, 114 insertions(+), 49 deletions(-)
arch/x86/include/asm/paravirt.h +3 -2
@@ -397,9 +397,10 @@ static inline void __flush_tlb_single(unsigned long addr)static inline void flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va) +unsigned long start, +unsigned long end) { -PVOP_VCALL3 (pv_mmu_ops.flush_tlb_others, cpumask, mm, va); +PVOP_VCALL4 (pv_mmu_ops.flush_tlb_others, cpumask, mm, start, end); }static inline int paravirt_pgd_alloc (struct mm_struct *mm)
arch/x86/include/asm/paravirt_types.h +2 -1
@@ -250,7 +250,8 @@ struct pv_mmu_ops {void (*flush_tlb_single)(unsigned long addr);void (*flush_tlb_others)(const struct cpumask *cpus,struct mm_struct *mm, -unsigned long va); +unsigned long start, +unsigned long end);/* Hooks for allocating and freeing a pagetable top-level */ int (*pgd_alloc)(struct mm_struct *mm);
arch/x86/include/asm/tlbflush.h +9 -14
@@ -73,14 +73,10 @@ static inline void __flush_tlb_one(unsigned long addr)* - flush_tlb_page(vma, vmaddr) flushes one page * - flush_tlb_range(vma, start, end) flushes a range of pages * - flush_tlb_kernel_range(start, end) flushes a range of kernel pages -* - flush_tlb_others(cpumask, mm, va) flushes TLBs on other cpus +* - flush_tlb_others(cpumask, mm, start, end) flushes TLBs on other cpus * * ..but the i386 has somewhat limited tlb flushing capabilities, * and page-granular flushes are available only on i486 and up. -* -* x86-64 can only flush individual pages or full VMs. For a range flush -* we always do the full VM. Might be worth trying if for a small -* range a few INVLPGs in a row are a win. */ #ifndef CONFIG_SMP
@@ -111,7 +107,8 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,static inline void native_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va) +unsigned long start, +unsigned long end) { }
@@ -129,17 +126,14 @@ extern void flush_tlb_all(void);extern void flush_tlb_current_task (void );extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); +extern void flush_tlb_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end);#define flush_tlb () flush_tlb_current_task() -static inline void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end) -{ -flush_tlb_mm (vma->vm_mm); -} -void native_flush_tlb_others (const struct cpumask *cpumask, -struct mm_struct *mm,unsigned long va); +struct mm_struct *mm, +unsigned long start,unsigned long end);#define TLBSTATE_OK 1#define TLBSTATE_LAZY 2
@@ -159,7 +153,8 @@ static inline void reset_lazy_tlbstate(void)#endif /* SMP */ #ifndef CONFIG_PARAVIRT -#define flush_tlb_others (mask, mm, va) native_flush_tlb_others(mask, mm, va) +#define flush_tlb_others (mask, mm, start, end) \ + native_flush_tlb_others(mask, mm, start, end)#endif static inline void flush_tlb_kernel_range(unsigned long start,
arch/x86/include/asm/uv/uv.h +3 -2
@@ -15,7 +15,8 @@ extern void uv_nmi_init(void);extern void uv_system_init (void );extern const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va, +unsigned long start, +unsigned end,unsigned int cpu);#else /* X86_UV */
@@ -26,7 +27,7 @@ static inline void uv_cpu_init(void) { }static inline void uv_system_init (void ) { }static inline const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask,struct mm_struct *mm, -unsigned long va,unsigned int cpu) +unsigned long start,unsigned long end,unsigned int cpu) {return cpumask; }#endif /* X86_UV */
arch/x86/mm/tlb.c +81 -16
168 lines not on this page · raw message
arch/x86/platform/uv/tlb_uv.c +3 -3
@@ -1068,8 +1068,8 @@ static int set_distrib_bits(struct cpumask *flush_mask, struct bau_control *bcp,* done. The returned pointer is valid till preemption is re-enabled. */ const struct cpumask *uv_flush_tlb_others (const struct cpumask *cpumask, -struct mm_struct *mm,unsigned long va, -unsigned int cpu) +struct mm_struct *mm,unsigned long start, +unsigned end,unsigned int cpu) {int locals =0 ;int remotes =0 ;
@@ -1112,7 +1112,7 @@ const struct cpumask *uv_flush_tlb_others(const struct cpumask *cpumask,record_send_statistics (stat, locals, hubs, remotes, bau_desc); - bau_desc->payload.address = va; + bau_desc->payload.address = start; bau_desc->payload.sending_cpu = cpu;/* * uv_flush_send_and_wait returns 0 if all cpu's were messaged,
arch/x86/xen/mmu.c +6 -6
@@ -1244,7 +1244,8 @@ static void xen_flush_tlb_single(unsigned long addr) }static void xen_flush_tlb_others (const struct cpumask *cpus, -struct mm_struct *mm,unsigned long va) +struct mm_struct *mm,unsigned long start, +unsigned long end) {struct {struct mmuext_op op;
@@ -1256,7 +1257,7 @@ static void xen_flush_tlb_others(const struct cpumask *cpus, } *args;struct multicall_space mcs; -trace_xen_mmu_flush_tlb_others (cpus, mm, va); +trace_xen_mmu_flush_tlb_others (cpus, mm, start, end);if (cpumask_empty (cpus))return ;/* nothing to do */
@@ -1269,11 +1270,10 @@ static void xen_flush_tlb_others(const struct cpumask *cpus,cpumask_and (to_cpumask (args->mask), cpus, cpu_online_mask);cpumask_clear_cpu (smp_processor_id (),to_cpumask (args->mask)); -if (va ==TLB_FLUSH_ALL ) { - args->op.cmd =MMUEXT_TLB_FLUSH_MULTI ; - }else { + args->op.cmd =MMUEXT_TLB_FLUSH_MULTI ; +if (start !=TLB_FLUSH_ALL && (end - start) <=PAGE_SIZE ) { args->op.cmd =MMUEXT_INVLPG_MULTI ; - args->op.arg1.linear_addr = va; + args->op.arg1.linear_addr = start; }MULTI_mmuext_op (mcs.mc, &args->op,1 ,NULL ,DOMID_SELF );
include/trace/events/xen.h +7 -5
@@ -397,18 +397,20 @@ TRACE_EVENT(xen_mmu_flush_tlb_single,TRACE_EVENT (xen_mmu_flush_tlb_others, TP_PROTO(const struct cpumask *cpus, struct mm_struct *mm, - unsigned long addr), -TP_ARGS (cpus, mm, addr), + unsigned long addr, unsigned long end), +TP_ARGS (cpus, mm, addr, end),TP_STRUCT__entry ( __field(unsigned, ncpus) __field(struct mm_struct *, mm) __field(unsigned long, addr) + __field(unsigned long, end) ), TP_fast_assign(__entry->ncpus = cpumask_weight(cpus); __entry->mm = mm; - __entry->addr = addr), -TP_printk ("ncpus %d mm %p addr %lx" , - __entry->ncpus, __entry->mm, __entry->addr) + __entry->addr = addr, + __entry->end = end), +TP_printk ("ncpus %d mm %p addr %lx, end %lx" , + __entry->ncpus, __entry->mm, __entry->addr, __entry->end) ); TRACE_EVENT(xen_mmu_write_cr3,
PATCH v10 3/9 x86/tlb: fall back to flush all when meet a THP large page
In reply to Alex ShiWe don't need to flush large pages by PAGE_SIZE step, that just waste time. and actually, large page don't need 'invlpg' optimizing according to our micro benchmark. So, just flush whole TLB is enough for them.
The following result is tested on a 2CPU * 4cores * 2HT NHM EP machine, with THP 'always' setting.
Multi-thread testing, '-t' paramter is thread number:
without this patch with this patch
./mprotect -t 1 14ns 13ns ./mprotect -t 2 13ns 13ns ./mprotect -t 4 12ns 11ns ./mprotect -t 8 14ns 10ns ./mprotect -t 16 28ns 28ns ./mprotect -t 32 54ns 52ns ./mprotect -t 128 200ns 200ns
--- arch/x86/mm/tlb.c | 34 ++++++++++++++++++++++++++++++++++ 1 files changed, 34 insertions(+), 0 deletions(-)
arch/x86/mm/tlb.c +34 -0
@@ -318,12 +318,42 @@ void flush_tlb_mm(struct mm_struct *mm)#define FLUSHALL_BAR 16 +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static inline unsigned long has_large_page (struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +pgd_t *pgd; +pud_t *pud; +pmd_t *pmd; +unsigned long addr =ALIGN (start,HPAGE_SIZE ); +for (; addr < end; addr +=HPAGE_SIZE ) { + pgd =pgd_offset (mm, addr); +if (likely (!pgd_none (*pgd))) { + pud =pud_offset (pgd, addr); +if (likely (!pud_none (*pud))) { + pmd =pmd_offset (pud, addr); +if (likely (!pmd_none (*pmd))) +if (pmd_large (*pmd)) +return addr; + } + } + } +return 0 ; +} +#else +static inline unsigned long has_large_page (struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +return 0 ; +} +#endif void flush_tlb_range (struct vm_area_struct *vma,unsigned long start,unsigned long end) {struct mm_struct *mm;if (!cpu_has_invlpg || vma->vm_flags &VM_HUGETLB ) { +flush_all:flush_tlb_mm (vma->vm_mm);return ; }
@@ -346,6 +376,10 @@ void flush_tlb_range(struct vm_area_struct *vma,if ((end - start)/PAGE_SIZE > act_entries/FLUSHALL_BAR )local_flush_tlb ();else { +if (has_large_page (mm, start, end)) { +preempt_enable (); + goto flush_all; + }for (addr = start; addr < end; addr +=PAGE_SIZE )__flush_tlb_single (addr);
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: fall back to flush all when meet a THP large page
Commit-ID: d8dfe60d6dcad5989c4558b753b98d657e2813c0 Gitweb: http://git.kernel.org/tip/d8dfe60d6dcad5989c4558b753b98d657e2813c0 Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:18 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:09 -0700
x86/tlb: fall back to flush all when meet a THP large page
We don't need to flush large pages by PAGE_SIZE step, that just waste time. and actually, large page don't need 'invlpg' optimizing according to our micro benchmark. So, just flush whole TLB is enough for them.
The following result is tested on a 2CPU * 4cores * 2HT NHM EP machine, with THP 'always' setting.
Multi-thread testing, '-t' paramter is thread number:
without this patch with this patch
./mprotect -t 1 14ns 13ns ./mprotect -t 2 13ns 13ns ./mprotect -t 4 12ns 11ns ./mprotect -t 8 14ns 10ns ./mprotect -t 16 28ns 28ns ./mprotect -t 32 54ns 52ns ./mprotect -t 128 200ns 200ns
--- arch/x86/mm/tlb.c | 34 ++++++++++++++++++++++++++++++++++ 1 files changed, 34 insertions(+), 0 deletions(-)
arch/x86/mm/tlb.c +34 -0
@@ -318,12 +318,42 @@ void flush_tlb_mm(struct mm_struct *mm)#define FLUSHALL_BAR 16 +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static inline unsigned long has_large_page (struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +pgd_t *pgd; +pud_t *pud; +pmd_t *pmd; +unsigned long addr =ALIGN (start,HPAGE_SIZE ); +for (; addr < end; addr +=HPAGE_SIZE ) { + pgd =pgd_offset (mm, addr); +if (likely (!pgd_none (*pgd))) { + pud =pud_offset (pgd, addr); +if (likely (!pud_none (*pud))) { + pmd =pmd_offset (pud, addr); +if (likely (!pmd_none (*pmd))) +if (pmd_large (*pmd)) +return addr; + } + } + } +return 0 ; +} +#else +static inline unsigned long has_large_page (struct mm_struct *mm, +unsigned long start,unsigned long end) +{ +return 0 ; +} +#endif void flush_tlb_range (struct vm_area_struct *vma,unsigned long start,unsigned long end) {struct mm_struct *mm;if (!cpu_has_invlpg || vma->vm_flags &VM_HUGETLB ) { +flush_all:flush_tlb_mm (vma->vm_mm);return ; }
@@ -346,6 +376,10 @@ void flush_tlb_range(struct vm_area_struct *vma,if ((end - start)/PAGE_SIZE > act_entries/FLUSHALL_BAR )local_flush_tlb ();else { +if (has_large_page (mm, start, end)) { +preempt_enable (); + goto flush_all; + }for (addr = start; addr < end; addr +=PAGE_SIZE )__flush_tlb_single (addr);
PATCH v10 4/9 x86/tlb: add tlb_flushall_shift for specific CPU
In reply to Alex ShiTesting show different CPU type(micro architectures and NUMA mode) has different balance points between the TLB flush all and multiple invlpg. And there also has cases the tlb flush change has no any help.
This patch give a interface to let x86 vendor developers have a chance to set different shift for different CPU type.
like some machine in my hands, balance points is 16 entries on Romely-EP; while it is at 8 entries on Bloomfield NHM-EP; and is 256 on IVB mobile CPU. but on model 15 core2 Xeon using invlpg has nothing help.
For untested machine, do a conservative optimization, same as NHM CPU.
--- arch/x86/include/asm/processor.h | 2 ++ arch/x86/kernel/cpu/common.c | 14 ++++++++++++-- arch/x86/kernel/cpu/intel.c | 34 ++++++++++++++++++++++++++++++++++ arch/x86/mm/tlb.c | 7 +++---- include/asm-generic/tlb.h | 3 ++- 5 files changed, 53 insertions(+), 7 deletions(-)
arch/x86/include/asm/processor.h +2 -0
@@ -72,6 +72,8 @@ extern u16 __read_mostly tlb_lli_4m[NR_INFO];extern u16 __read_mostly tlb_lld_4k[NR_INFO ];extern u16 __read_mostly tlb_lld_2m[NR_INFO ];extern u16 __read_mostly tlb_lld_4m[NR_INFO ]; +extern s8 __read_mostly tlb_flushall_shift; +/* * CPU type and hardware bug flags. Kept separately for each CPU. * Members of this structure are referenced in head.S, so think twice
arch/x86/kernel/cpu/common.c +12 -2
@@ -459,16 +459,26 @@ u16 __read_mostly tlb_lld_4k[NR_INFO];u16 __read_mostly tlb_lld_2m[NR_INFO ];u16 __read_mostly tlb_lld_4m[NR_INFO ]; +/* +* tlb_flushall_shift shows the balance point in replacing cr3 write +* with multiple 'invlpg'. It will do this replacement when +* flush_tlb_lines <= active_lines/2^tlb_flushall_shift. +* If tlb_flushall_shift is -1, means the replacement will be disabled. +*/ +s8 __read_mostly tlb_flushall_shift =-1 ; +void __cpuinit cpu_detect_tlb (struct cpuinfo_x86 *c) {if (this_cpu->c_detect_tlb) this_cpu->c_detect_tlb (c);printk (KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ -"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" , +"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ +"tlb_flushall_shift is 0x%x\n" , tlb_lli_4k[ENTRIES ], tlb_lli_2m[ENTRIES ], tlb_lli_4m[ENTRIES ], tlb_lld_4k[ENTRIES ], - tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ]); + tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ], + tlb_flushall_shift); }void __cpuinit detect_ht (struct cpuinfo_x86 *c)
arch/x86/kernel/cpu/intel.c +34 -0
@@ -610,6 +610,39 @@ static void __cpuinit intel_tlb_lookup(const unsigned char desc) } } +static void __cpuinit intel_tlb_flushall_shift_set (struct cpuinfo_x86 *c) +{ +if (!cpu_has_invlpg) { + tlb_flushall_shift =-1 ; +return ; + } +switch ((c->x86 <<8 ) + c->x86_model) { +case 0x60f :/* original 65 nm celeron/pentium/core2/xeon, "Merom"/"Conroe" */ +case 0x616 :/* single-core 65 nm celeron/core2solo "Merom-L"/"Conroe-L" */ +case 0x617 :/* current 45 nm celeron/core2/xeon "Penryn"/"Wolfdale" */ +case 0x61d :/* six-core 45 nm xeon "Dunnington" */ + tlb_flushall_shift =-1 ; +break ; +case 0x61a :/* 45 nm nehalem, "Bloomfield" */ +case 0x61e :/* 45 nm nehalem, "Lynnfield" */ +case 0x625 :/* 32 nm nehalem, "Clarkdale" */ +case 0x62c :/* 32 nm nehalem, "Gulftown" */ +case 0x62e :/* 45 nm nehalem-ex, "Beckton" */ +case 0x62f :/* 32 nm Xeon E7 */ + tlb_flushall_shift =6 ; +break ; +case 0x62a :/* SandyBridge */ +case 0x62d :/* SandyBridge, "Romely-EP" */ + tlb_flushall_shift =5 ; +break ; +case 0x63a :/* Ivybridge */ + tlb_flushall_shift =1 ; +break ; +default : + tlb_flushall_shift =6 ; + } +} +static void __cpuinit intel_detect_tlb (struct cpuinfo_x86 *c) {int i, j, n;
@@ -630,6 +663,7 @@ static void __cpuinit intel_detect_tlb(struct cpuinfo_x86 *c)for (j =1 ; j <16 ; j++)intel_tlb_lookup (desc[j]); } +intel_tlb_flushall_shift_set (c); }static const struct cpu_dev __cpuinitconst intel_cpu_dev = {
arch/x86/mm/tlb.c +3 -4
@@ -316,8 +316,6 @@ void flush_tlb_mm(struct mm_struct *mm)preempt_enable (); } -#define FLUSHALL_BAR 16 -#ifdef CONFIG_TRANSPARENT_HUGEPAGE static inline unsigned long has_large_page (struct mm_struct *mm,unsigned long start,unsigned long end)
@@ -352,7 +350,7 @@ void flush_tlb_range(struct vm_area_struct *vma, {struct mm_struct *mm; -if (!cpu_has_invlpg || vma->vm_flags &VM_HUGETLB ) { +if (vma->vm_flags &VM_HUGETLB || tlb_flushall_shift ==-1 ) { flush_all:flush_tlb_mm (vma->vm_mm);return ;
@@ -373,7 +371,8 @@ flush_all: act_entries = tlb_entries > mm->total_vm ? mm->total_vm : tlb_entries; -if ((end - start)/PAGE_SIZE > act_entries/FLUSHALL_BAR ) +if ((end - start) >>PAGE_SHIFT > + act_entries >> tlb_flushall_shift)local_flush_tlb ();else {if (has_large_page (mm, start, end)) {
include/asm-generic/tlb.h +2 -1
@@ -113,7 +113,8 @@ static inline int tlb_fast_mode(struct mmu_gather *tlb)void tlb_gather_mmu (struct mmu_gather *tlb,struct mm_struct *mm,bool fullmm);void tlb_flush_mmu (struct mmu_gather *tlb); -void tlb_finish_mmu (struct mmu_gather *tlb,unsigned long start,unsigned long end); +void tlb_finish_mmu (struct mmu_gather *tlb,unsigned long start, +unsigned long end);int __tlb_remove_page (struct mmu_gather *tlb,struct page *page);/* tlb_remove_page
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: add tlb_flushall_shift for specific CPU
Commit-ID: c4211f42d3e66875298a5e26a75109878c80f15b Gitweb: http://git.kernel.org/tip/c4211f42d3e66875298a5e26a75109878c80f15b Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:19 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:10 -0700
x86/tlb: add tlb_flushall_shift for specific CPU
Testing show different CPU type(micro architectures and NUMA mode) has different balance points between the TLB flush all and multiple invlpg. And there also has cases the tlb flush change has no any help.
This patch give a interface to let x86 vendor developers have a chance to set different shift for different CPU type.
like some machine in my hands, balance points is 16 entries on Romely-EP; while it is at 8 entries on Bloomfield NHM-EP; and is 256 on IVB mobile CPU. but on model 15 core2 Xeon using invlpg has nothing help.
For untested machine, do a conservative optimization, same as NHM CPU.
--- arch/x86/include/asm/processor.h | 2 ++ arch/x86/kernel/cpu/common.c | 14 ++++++++++++-- arch/x86/kernel/cpu/intel.c | 34 ++++++++++++++++++++++++++++++++++ arch/x86/mm/tlb.c | 7 +++---- include/asm-generic/tlb.h | 3 ++- 5 files changed, 53 insertions(+), 7 deletions(-)
arch/x86/include/asm/processor.h +2 -0
@@ -72,6 +72,8 @@ extern u16 __read_mostly tlb_lli_4m[NR_INFO];extern u16 __read_mostly tlb_lld_4k[NR_INFO ];extern u16 __read_mostly tlb_lld_2m[NR_INFO ];extern u16 __read_mostly tlb_lld_4m[NR_INFO ]; +extern s8 __read_mostly tlb_flushall_shift; +/* * CPU type and hardware bug flags. Kept separately for each CPU. * Members of this structure are referenced in head.S, so think twice
arch/x86/kernel/cpu/common.c +12 -2
@@ -459,16 +459,26 @@ u16 __read_mostly tlb_lld_4k[NR_INFO];u16 __read_mostly tlb_lld_2m[NR_INFO ];u16 __read_mostly tlb_lld_4m[NR_INFO ]; +/* +* tlb_flushall_shift shows the balance point in replacing cr3 write +* with multiple 'invlpg'. It will do this replacement when +* flush_tlb_lines <= active_lines/2^tlb_flushall_shift. +* If tlb_flushall_shift is -1, means the replacement will be disabled. +*/ +s8 __read_mostly tlb_flushall_shift =-1 ; +void __cpuinit cpu_detect_tlb (struct cpuinfo_x86 *c) {if (this_cpu->c_detect_tlb) this_cpu->c_detect_tlb (c);printk (KERN_INFO "Last level iTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ -"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" , +"Last level dTLB entries: 4KB %d, 2MB %d, 4MB %d\n" \ +"tlb_flushall_shift is 0x%x\n" , tlb_lli_4k[ENTRIES ], tlb_lli_2m[ENTRIES ], tlb_lli_4m[ENTRIES ], tlb_lld_4k[ENTRIES ], - tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ]); + tlb_lld_2m[ENTRIES ], tlb_lld_4m[ENTRIES ], + tlb_flushall_shift); }void __cpuinit detect_ht (struct cpuinfo_x86 *c)
arch/x86/kernel/cpu/intel.c +34 -0
@@ -610,6 +610,39 @@ static void __cpuinit intel_tlb_lookup(const unsigned char desc) } } +static void __cpuinit intel_tlb_flushall_shift_set (struct cpuinfo_x86 *c) +{ +if (!cpu_has_invlpg) { + tlb_flushall_shift =-1 ; +return ; + } +switch ((c->x86 <<8 ) + c->x86_model) { +case 0x60f :/* original 65 nm celeron/pentium/core2/xeon, "Merom"/"Conroe" */ +case 0x616 :/* single-core 65 nm celeron/core2solo "Merom-L"/"Conroe-L" */ +case 0x617 :/* current 45 nm celeron/core2/xeon "Penryn"/"Wolfdale" */ +case 0x61d :/* six-core 45 nm xeon "Dunnington" */ + tlb_flushall_shift =-1 ; +break ; +case 0x61a :/* 45 nm nehalem, "Bloomfield" */ +case 0x61e :/* 45 nm nehalem, "Lynnfield" */ +case 0x625 :/* 32 nm nehalem, "Clarkdale" */ +case 0x62c :/* 32 nm nehalem, "Gulftown" */ +case 0x62e :/* 45 nm nehalem-ex, "Beckton" */ +case 0x62f :/* 32 nm Xeon E7 */ + tlb_flushall_shift =6 ; +break ; +case 0x62a :/* SandyBridge */ +case 0x62d :/* SandyBridge, "Romely-EP" */ + tlb_flushall_shift =5 ; +break ; +case 0x63a :/* Ivybridge */ + tlb_flushall_shift =1 ; +break ; +default : + tlb_flushall_shift =6 ; + } +} +static void __cpuinit intel_detect_tlb (struct cpuinfo_x86 *c) {int i, j, n;
@@ -630,6 +663,7 @@ static void __cpuinit intel_detect_tlb(struct cpuinfo_x86 *c)for (j =1 ; j <16 ; j++)intel_tlb_lookup (desc[j]); } +intel_tlb_flushall_shift_set (c); }static const struct cpu_dev __cpuinitconst intel_cpu_dev = {
arch/x86/mm/tlb.c +3 -4
@@ -316,8 +316,6 @@ void flush_tlb_mm(struct mm_struct *mm)preempt_enable (); } -#define FLUSHALL_BAR 16 -#ifdef CONFIG_TRANSPARENT_HUGEPAGE static inline unsigned long has_large_page (struct mm_struct *mm,unsigned long start,unsigned long end)
@@ -352,7 +350,7 @@ void flush_tlb_range(struct vm_area_struct *vma, {struct mm_struct *mm; -if (!cpu_has_invlpg || vma->vm_flags &VM_HUGETLB ) { +if (vma->vm_flags &VM_HUGETLB || tlb_flushall_shift ==-1 ) { flush_all:flush_tlb_mm (vma->vm_mm);return ;
@@ -373,7 +371,8 @@ flush_all: act_entries = tlb_entries > mm->total_vm ? mm->total_vm : tlb_entries; -if ((end - start)/PAGE_SIZE > act_entries/FLUSHALL_BAR ) +if ((end - start) >>PAGE_SHIFT > + act_entries >> tlb_flushall_shift)local_flush_tlb ();else {if (has_large_page (mm, start, end)) {
include/asm-generic/tlb.h +2 -1
@@ -113,7 +113,8 @@ static inline int tlb_fast_mode(struct mmu_gather *tlb)void tlb_gather_mmu (struct mmu_gather *tlb,struct mm_struct *mm,bool fullmm);void tlb_flush_mmu (struct mmu_gather *tlb); -void tlb_finish_mmu (struct mmu_gather *tlb,unsigned long start,unsigned long end); +void tlb_finish_mmu (struct mmu_gather *tlb,unsigned long start, +unsigned long end);int __tlb_remove_page (struct mmu_gather *tlb,struct page *page);/* tlb_remove_page
PATCH v10 5/9 x86/tlb: add tlb_flushall_shift knob into debugfs
In reply to Alex Shikernel will replace cr3 rewrite with invlpg when
tlb_flush_entries <= active_tlb_entries / 2^tlb_flushall_factor
if tlb_flushall_factor is -1, kernel won't do this replacement.
User can modify its value according to specific CPU/applications.
Thanks for Borislav providing the help message ofCONFIG_DEBUG_TLBFLUSH.
--- arch/x86/Kconfig.debug | 19 +++++++++++++++++ arch/x86/mm/tlb.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 0 deletions(-)
arch/x86/Kconfig.debug +19 -0
@@ -129,6 +129,25 @@ config DOUBLEFAULT option saves about 4k and might cause you much additional grey hair. +config DEBUG_TLBFLUSH + bool "Set upper limit of TLB entries to flush one-by-one" + depends on DEBUG_KERNEL && (X86_64 || X86_INVLPG) + ---help--- + + X86-only for now. + + This option allows the user to tune the amount of TLB entries the + kernel flushes one-by-one instead of doing a full TLB flush. In + certain situations, the former is cheaper. This is controlled by the + tlb_flushall_shift knob under /sys/kernel/debug/x86. If you set it + to -1, the code flushes the whole TLB unconditionally. Otherwise, + for positive values of it, the kernel will use single TLB entry + invalidating instructions according to the following formula: + + flush_entries <= active_tlb_entries / 2^tlb_flushall_shift + + If in doubt, say "N". + config IOMMU_DEBUG bool "Enable IOMMU debugging" depends on GART_IOMMU && DEBUG_KERNEL
arch/x86/mm/tlb.c +51 -0
60 lines not on this page · raw message
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: add tlb_flushall_shift knob into debugfs
Commit-ID: 3df3212f9722c7e45c723b9ea231a04ba4dbc47c Gitweb: http://git.kernel.org/tip/3df3212f9722c7e45c723b9ea231a04ba4dbc47c Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:20 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:10 -0700
x86/tlb: add tlb_flushall_shift knob into debugfs
kernel will replace cr3 rewrite with invlpg when
tlb_flush_entries <= active_tlb_entries / 2^tlb_flushall_factor
if tlb_flushall_factor is -1, kernel won't do this replacement.
User can modify its value according to specific CPU/applications.
Thanks for Borislav providing the help message ofCONFIG_DEBUG_TLBFLUSH.
--- arch/x86/Kconfig.debug | 19 +++++++++++++++++ arch/x86/mm/tlb.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 0 deletions(-)
arch/x86/Kconfig.debug +19 -0
@@ -129,6 +129,25 @@ config DOUBLEFAULT option saves about 4k and might cause you much additional grey hair. +config DEBUG_TLBFLUSH + bool "Set upper limit of TLB entries to flush one-by-one" + depends on DEBUG_KERNEL && (X86_64 || X86_INVLPG) + ---help--- + + X86-only for now. + + This option allows the user to tune the amount of TLB entries the + kernel flushes one-by-one instead of doing a full TLB flush. In + certain situations, the former is cheaper. This is controlled by the + tlb_flushall_shift knob under /sys/kernel/debug/x86. If you set it + to -1, the code flushes the whole TLB unconditionally. Otherwise, + for positive values of it, the kernel will use single TLB entry + invalidating instructions according to the following formula: + + flush_entries <= active_tlb_entries / 2^tlb_flushall_shift + + If in doubt, say "N". + config IOMMU_DEBUG bool "Enable IOMMU debugging" depends on GART_IOMMU && DEBUG_KERNEL
arch/x86/mm/tlb.c +51 -0
60 lines not on this page · raw message
PATCH v10 6/9 mm/mmu_gather: enable tlb flush range in generic mmu_gather
In reply to Alex ShiThis patch enabled the tlb flush range support in generic mmu layer.
Most of arch has self tlb flush range support, like ARM/IA64 etc. X86 arch has no this support in hardware yet. But another instruction 'invlpg' can implement this function in some degree. So, enable this feather in generic layer for x86 now. and maybe useful for other archs in further.
Generic mmu_gather struct is protected by micro HAVE_GENERIC_MMU_GATHER. Other archs that has flush range supported own self mmu_gather struct. So, now this change is safe for them.
In future we may unify this struct and related functions on multiple archs.
Thanks for Peter Zijlstra time and time reminder for multiple architecture code safe!
--- include/asm-generic/tlb.h | 2 ++ mm/memory.c | 9 +++++++++ 2 files changed, 11 insertions(+), 0 deletions(-)
include/asm-generic/tlb.h +2 -0
@@ -86,6 +86,8 @@ struct mmu_gather {#ifdef CONFIG_HAVE_RCU_TABLE_FREE struct mmu_table_batch *batch;#endif +unsigned long start; +unsigned long end; unsigned int need_flush : 1, /* Did free PTEs */ fast_mode : 1; /* No batching */
mm/memory.c +9 -0
@@ -206,6 +206,8 @@ void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, bool fullmm) tlb->mm = mm; tlb->fullmm = fullmm; + tlb->start =-1UL ; + tlb->end =0 ; tlb->need_flush =0 ; tlb->fast_mode = (num_possible_cpus () ==1 ); tlb->local.next =NULL ;
@@ -248,6 +250,8 @@ void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long e {struct mmu_gather_batch *batch, *next; + tlb->start = start; + tlb->end = end;tlb_flush_mmu (tlb);/* keep the page table cache within bounds */
@@ -1204,6 +1208,11 @@ again:*/ if (force_flush) { force_flush =0 ; + +#ifdef HAVE_GENERIC_MMU_GATHER + tlb->start = addr; + tlb->end = end; +#endif tlb_flush_mmu (tlb);if (addr != end) goto again;
Signature · 1 line
1.7.5.4
[tip:x86/mm] mm/mmu_gather: enable tlb flush range in generic mmu_gather
Commit-ID: 597e1c3580b7cfd95bb0f3167e2b297bf8a5a3ae Gitweb: http://git.kernel.org/tip/597e1c3580b7cfd95bb0f3167e2b297bf8a5a3ae Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:21 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:11 -0700
mm/mmu_gather: enable tlb flush range in generic mmu_gather
This patch enabled the tlb flush range support in generic mmu layer.
Most of arch has self tlb flush range support, like ARM/IA64 etc. X86 arch has no this support in hardware yet. But another instruction 'invlpg' can implement this function in some degree. So, enable this feather in generic layer for x86 now. and maybe useful for other archs in further.
Generic mmu_gather struct is protected by micro HAVE_GENERIC_MMU_GATHER. Other archs that has flush range supported own self mmu_gather struct. So, now this change is safe for them.
In future we may unify this struct and related functions on multiple archs.
Thanks for Peter Zijlstra time and time reminder for multiple architecture code safe!
--- include/asm-generic/tlb.h | 2 ++ mm/memory.c | 9 +++++++++ 2 files changed, 11 insertions(+), 0 deletions(-)
include/asm-generic/tlb.h +2 -0
@@ -86,6 +86,8 @@ struct mmu_gather {#ifdef CONFIG_HAVE_RCU_TABLE_FREE struct mmu_table_batch *batch;#endif +unsigned long start; +unsigned long end; unsigned int need_flush : 1, /* Did free PTEs */ fast_mode : 1; /* No batching */
mm/memory.c +9 -0
@@ -206,6 +206,8 @@ void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, bool fullmm) tlb->mm = mm; tlb->fullmm = fullmm; + tlb->start =-1UL ; + tlb->end =0 ; tlb->need_flush =0 ; tlb->fast_mode = (num_possible_cpus () ==1 ); tlb->local.next =NULL ;
@@ -248,6 +250,8 @@ void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long e {struct mmu_gather_batch *batch, *next; + tlb->start = start; + tlb->end = end;tlb_flush_mmu (tlb);/* keep the page table cache within bounds */
@@ -1204,6 +1208,11 @@ again:*/ if (force_flush) { force_flush =0 ; + +#ifdef HAVE_GENERIC_MMU_GATHER + tlb->start = addr; + tlb->end = end; +#endif tlb_flush_mmu (tlb);if (addr != end) goto again;
PATCH v10 7/9 x86/tlb: enable tlb flush range support for x86
In reply to Alex ShiNot every tlb_flush execution moment is really need to evacuate all TLB entries, like in munmap, just few 'invlpg' is better for whole process performance, since it leaves most of TLB entries for later accessing.
This patch also rewrite flush_tlb_range for 2 purposes:
1, split it out to get flush_blt_mm_range function.
2, clean up to reduce line breaking, thanks for Borislav's input.
My micro benchmark 'mummap' http://lkml.org/lkml/2012/5/17/59
show that the random memory access on other CPU has 0~50% speed up on a 2P * 4cores * HT NHM EP while do 'munmap'.
Thanks Yongjie's testing on this patch:
-------------
I used Linux 3.4-RC6 w/ and w/o his patches as Xen dom0 and guest kernel.
After running two benchmarks in Xen HVM guest, I found his patches brought about 1%~3% performance gain in 'kernel build' and 'netperf' testing, though the performance gain was not very stable in 'kernel build' testing.
Some detailed testing results are below.
Testing Environment:
Hardware: Romley-EP platform
Xen version: latest upstream
Linux kernel: 3.4-RC6
Guest vCPU number: 8
NIC: Intel 82599 (10GB bandwidth)
In 'kernel build' testing in guest:
Command line | performance gain
make -j 4 | 3.81%
make -j 8 | 0.37%
make -j 16 | -0.52%In 'netperf' testing, we tested TCP_STREAM with default socket size 16384 byte as large packet and 64 byte as small packet.
I used several clients to add networking pressure, then 'netperf' server automatically generated several threads to response them.
I also used large-size packet and small-size packet in the testing.
Packet size | Thread number | performance gain 16384 bytes | 4 | 0.02% 16384 bytes | 8 | 2.21% 16384 bytes | 16 | 2.04% 64 bytes | 4 | 1.07% 64 bytes | 8 | 3.31% 64 bytes | 16 | 0.71%
--- arch/x86/include/asm/tlb.h | 9 +++- arch/x86/include/asm/tlbflush.h | 17 +++++- arch/x86/mm/tlb.c | 112 ++++++++++++++++----------------------- 3 files changed, 68 insertions(+), 70 deletions(-)
arch/x86/include/asm/tlb.h +8 -1
@@ -4,7 +4,14 @@#define tlb_start_vma (tlb, vma) do { } while (0)#define tlb_end_vma (tlb, vma) do { } while (0)#define __tlb_remove_tlb_entry (tlb, ptep, address) do { } while (0) -#define tlb_flush (tlb) flush_tlb_mm((tlb)->mm) + +#define tlb_flush (tlb) \ +{ \ + if (tlb->fullmm == 0) \ + flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end, 0UL); \ + else \ + flush_tlb_mm_range(tlb->mm, 0UL, TLB_FLUSH_ALL, 0UL); \ +}#include <asm-generic/tlb.h>
arch/x86/include/asm/tlbflush.h +14 -3
@@ -105,6 +105,13 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,__flush_tlb (); } +static inline void flush_tlb_mm_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (vma->vm_mm == current->active_mm) +__flush_tlb (); +} + static inline void native_flush_tlb_others(const struct cpumask *cpumask, struct mm_struct *mm, unsigned long start,
@@ -122,12 +129,16 @@ static inline void reset_lazy_tlbstate(void)#define local_flush_tlb () __flush_tlb() +#define flush_tlb_mm (mm) flush_tlb_mm_range(mm, 0UL, TLB_FLUSH_ALL, 0UL) + +#define flush_tlb_range (vma, start, end) \ + flush_tlb_mm_range(vma->vm_mm, start, end, vma->vm_flags) +extern void flush_tlb_all (void );extern void flush_tlb_current_task (void ); -extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); -extern void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end); +extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start, +unsigned long end,unsigned long vmflag);#define flush_tlb () flush_tlb_current_task()
arch/x86/mm/tlb.c +46 -66
137 lines not on this page · raw message
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: enable tlb flush range support for x86
Commit-ID: 611ae8e3f5204f7480b3b405993b3352cfa16662 Gitweb: http://git.kernel.org/tip/611ae8e3f5204f7480b3b405993b3352cfa16662 Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:22 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:11 -0700
x86/tlb: enable tlb flush range support for x86
Not every tlb_flush execution moment is really need to evacuate all TLB entries, like in munmap, just few 'invlpg' is better for whole process performance, since it leaves most of TLB entries for later accessing.
This patch also rewrite flush_tlb_range for 2 purposes:
1, split it out to get flush_blt_mm_range function.
2, clean up to reduce line breaking, thanks for Borislav's input.
My micro benchmark 'mummap' http://lkml.org/lkml/2012/5/17/59
show that the random memory access on other CPU has 0~50% speed up on a 2P * 4cores * HT NHM EP while do 'munmap'.
Thanks Yongjie's testing on this patch:
-------------
I used Linux 3.4-RC6 w/ and w/o his patches as Xen dom0 and guest kernel.
After running two benchmarks in Xen HVM guest, I found his patches brought about 1%~3% performance gain in 'kernel build' and 'netperf' testing, though the performance gain was not very stable in 'kernel build' testing.
Some detailed testing results are below.
Testing Environment:
Hardware: Romley-EP platform
Xen version: latest upstream
Linux kernel: 3.4-RC6
Guest vCPU number: 8
NIC: Intel 82599 (10GB bandwidth)
In 'kernel build' testing in guest:
Command line | performance gain
make -j 4 | 3.81%
make -j 8 | 0.37%
make -j 16 | -0.52%In 'netperf' testing, we tested TCP_STREAM with default socket size 16384 byte as large packet and 64 byte as small packet.
I used several clients to add networking pressure, then 'netperf' server automatically generated several threads to response them.
I also used large-size packet and small-size packet in the testing.
Packet size | Thread number | performance gain 16384 bytes | 4 | 0.02% 16384 bytes | 8 | 2.21% 16384 bytes | 16 | 2.04% 64 bytes | 4 | 1.07% 64 bytes | 8 | 3.31% 64 bytes | 16 | 0.71%
--- arch/x86/include/asm/tlb.h | 9 +++- arch/x86/include/asm/tlbflush.h | 17 +++++- arch/x86/mm/tlb.c | 112 ++++++++++++++++----------------------- 3 files changed, 68 insertions(+), 70 deletions(-)
arch/x86/include/asm/tlb.h +8 -1
@@ -4,7 +4,14 @@#define tlb_start_vma (tlb, vma) do { } while (0)#define tlb_end_vma (tlb, vma) do { } while (0)#define __tlb_remove_tlb_entry (tlb, ptep, address) do { } while (0) -#define tlb_flush (tlb) flush_tlb_mm((tlb)->mm) + +#define tlb_flush (tlb) \ +{ \ + if (tlb->fullmm == 0) \ + flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end, 0UL); \ + else \ + flush_tlb_mm_range(tlb->mm, 0UL, TLB_FLUSH_ALL, 0UL); \ +}#include <asm-generic/tlb.h>
arch/x86/include/asm/tlbflush.h +14 -3
@@ -105,6 +105,13 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,__flush_tlb (); } +static inline void flush_tlb_mm_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (vma->vm_mm == current->active_mm) +__flush_tlb (); +} + static inline void native_flush_tlb_others(const struct cpumask *cpumask, struct mm_struct *mm, unsigned long start,
@@ -122,12 +129,16 @@ static inline void reset_lazy_tlbstate(void)#define local_flush_tlb () __flush_tlb() +#define flush_tlb_mm (mm) flush_tlb_mm_range(mm, 0UL, TLB_FLUSH_ALL, 0UL) + +#define flush_tlb_range (vma, start, end) \ + flush_tlb_mm_range(vma->vm_mm, start, end, vma->vm_flags) +extern void flush_tlb_all (void );extern void flush_tlb_current_task (void ); -extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); -extern void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end); +extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start, +unsigned long end,unsigned long vmflag);#define flush_tlb () flush_tlb_current_task()
arch/x86/mm/tlb.c +46 -66
137 lines not on this page · raw message
Re: [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86
In reply to Alex ShiQuoted 83 lines · Alex Shi
Not every
tlb_flushexecution moment is really need to evacuate all TLB entries, like in munmap, just few 'invlpg' is better for whole process performance, since it leaves most of TLB entries for later accessing.This patch also rewrite
flush_tlb_rangefor 2 purposes:
1, split it out to getflush_blt_mm_rangefunction.
2, clean up to reduce line breaking, thanks for Borislav's input.My micro benchmark 'mummap' http://lkml.org/lkml/2012/5/17/59
show that the random memory access on other CPU has 0~50% speed up on a 2P * 4cores * HT NHM EP while do 'munmap'.Thanks Yongjie's testing on this patch:
-------------
I used Linux 3.4-RC6 w/ and w/o his patches as Xen dom0 and guest kernel.
After running two benchmarks in Xen HVM guest, I found his patches brought about 1%~3% performance gain in 'kernel build' and 'netperf' testing, though the performance gain was not very stable in 'kernel build' testing.Some detailed testing results are below.
Testing Environment:
Hardware: Romley-EP platform
Xen version: latest upstream
Linux kernel: 3.4-RC6
Guest vCPU number: 8
NIC: Intel 82599 (10GB bandwidth)In 'kernel build' testing in guest:
Command line | performance gain make -j 4 | 3.81% make -j 8 | 0.37% make -j 16 | -0.52%In 'netperf' testing, we tested
TCP_STREAMwith default socket size 16384 byte as large packet and 64 byte as small packet.
I used several clients to add networking pressure, then 'netperf' server automatically generated several threads to response them.
I also used large-size packet and small-size packet in the testing.Packet size | Thread number | performance gain 16384 bytes | 4 | 0.02% 16384 bytes | 8 | 2.21% 16384 bytes | 16 | 2.04% 64 bytes | 4 | 1.07% 64 bytes | 8 | 3.31% 64 bytes | 16 | 0.71%Signed-off-by Alex Shi <[email protected]>Tested-by Ren, Yongjie <[email protected]>--- arch/x86/include/asm/tlb.h | 9 +++- arch/x86/include/asm/tlbflush.h | 17 +++++- arch/x86/mm/tlb.c | 112 ++++++++++++++++----------------------- 3 files changed, 68 insertions(+), 70 deletions(-)arch/x86/include/asm/tlb.h +8
-1@@ -4,7 +4,14 @@#define tlb_start_vma (tlb, vma) do { } while (0)#define tlb_end_vma (tlb, vma) do { } while (0)#define __tlb_remove_tlb_entry (tlb, ptep, address) do { } while (0) -#define tlb_flush (tlb) flush_tlb_mm((tlb)->mm) + +#define tlb_flush (tlb) \ +{ \ + if (tlb->fullmm == 0) \ + flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end, 0UL); \ + else \ + flush_tlb_mm_range(tlb->mm, 0UL, TLB_FLUSH_ALL, 0UL); \ +}#include <asm-generic/tlb.h> arch/x86/include/asm/tlbflush.h +0
-0
arch/x86/include/asm/tlbflush.h static inline void flush_tlb_range(struct vm_area_struct *vma, · line 113
Quoted 9 lines
arch/x86/include/asm/tlbflush.h +6
-0@@ -105,6 +105,13 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,__flush_tlb (); } +static inline void flush_tlb_mm_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (vma->vm_mm == current->active_mm) +__flush_tlb (); +}
There's a problem with this in one of my randconfig tests. It has !CONFIG_SMP and the warning is:
mm/memory.c: In function ‘tlb_flush_mmu’:mm/memory.c:230:2: warning: passing argument 1 of ‘flush_tlb_mm_range’ from incompatible pointer type /usr/src/linux-2.6/arch/x86/include/asm/tlbflush.h:108:20: note: expected ‘struct vm_area_struct *’ but argument is of type ‘struct mm_struct *’ mm/memory.c:230:2: warning: passing argument 1 of ‘flush_tlb_mm_range’ from incompatible pointer type /usr/src/linux-2.6/arch/x86/include/asm/tlbflush.h:108:20: note: expected ‘struct vm_area_struct *’ but argument is of type ‘struct mm_struct *’
Due to the fact that the macro flush_tlb actually resolves to flush_tlb_mm_range and this function has a different signature based on CONFIG_SMP. On !SMP expects struct vm_area_struct * as a first argument but on SMP its first argument is struct mm_struct *.
So two different function signatures based on a config option? Now that's a first. What is going on?
Signature · 8 lines
Regards/Gruss, Boris. Advanced Micro Devices GmbH Einsteinring 24, 85609 Dornach GM: Alberto Bozzo Reg: Dornach, Landkreis Muenchen HRB Nr. 43632 WEEE Registernr: 129 19551
Re: [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86
Quoted 19 lines
arch/x86/include/asm/tlbflush.h static inline void flush_tlb_range(struct vm_area_struct *vma, · line 113
Quoted 8 lines
arch/x86/include/asm/tlbflush.h +6
-0+static inline void flush_tlb_mm_range (struct vm_area_struct *vma, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (vma->vm_mm == current->active_mm) +__flush_tlb (); +}There's a problem with this in one of my randconfig tests. It has !CONFIG_SMP and the warning is:
mm/memory.c: In function ‘tlb_flush_mmu’:mm/memory.c:230:2: warning: passing argument 1 of ‘flush_tlb_mm_range’ from incompatible pointer type/usr/src/linux-2.6/arch/x86/include/asm/tlbflush.h:108:20: note: expected ‘structvm_area_struct*’ but argument is of type ‘structmm_struct*’mm/memory.c:230:2: warning: passing argument 1 of ‘flush_tlb_mm_range’ from incompatible pointer type/usr/src/linux-2.6/arch/x86/include/asm/tlbflush.h:108:20: note: expected ‘structvm_area_struct*’ but argument is of type ‘structmm_struct*’
Quoted 7 lines
Due to the fact that the macro
flush_tlbactually resolves toflush_tlb_mm_rangeand this function has a different signature based onCONFIG_SMP. On !SMP expects structvm_area_struct* as a first argument but on SMP its first argument is structmm_struct*.So two different function signatures based on a config option? Now that's a first. What is going on?
Sure, it is a bug, the fix had sent:
https://lkml.org/lkml/2012/7/6/350
Quoted 1 line
H. Peter Anvin
reviewerRe: [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86
Quoted 4 lines · Alex Shi
Sure, it is a bug, the fix had sent:
https://lkml.org/lkml/2012/7/6/350
Could you please re-send that as a clean patch?
-hpa
Alex Shi
Tested-by Ren, YongjieRe: [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86
Quoted 10 lines · H. Peter Anvin
Quoted 4 lines · Alex Shi
Sure, it is a bug, the fix had sent:
https://lkml.org/lkml/2012/7/6/350Could you please re-send that as a clean patch?
-hpa
Since, it has not impact for the serial left patches, and linux-next has not merge this patchset. I folded this patch into original. Is that ok, or need a separated one?
===
Quoted 1 line
From
2e6117dfda5b323261e959bb5faf778cbe4b3c64Mon Sep 17 00:00:00 2001
From: Alex Shi <[email protected]>
Date: Mon, 25 Jun 2012 11:06:46 +0800
Subject: [PATCH 7/9] x86/tlb: enable tlb flush range support for x86
Not every tlb_flush execution moment is really need to evacuate all TLB entries, like in munmap, just few 'invlpg' is better for whole process performance, since it leaves most of TLB entries for later accessing.
This patch also rewrite flush_tlb_range for 2 purposes:
1, split it out to get flush_blt_mm_range function.
2, clean up to reduce line breaking, thanks for Borislav's input.
My micro benchmark 'mummap' http://lkml.org/lkml/2012/5/17/59
show that the random memory access on other CPU has 0~50% speed up on a 2P * 4cores * HT NHM EP while do 'munmap'.
Thanks Yongjie's testing on this patch:
-------------
I used Linux 3.4-RC6 w/ and w/o his patches as Xen dom0 and guest kernel.
After running two benchmarks in Xen HVM guest, I found his patches brought about 1%~3% performance gain in 'kernel build' and 'netperf' testing, though the performance gain was not very stable in 'kernel build' testing.
Some detailed testing results are below.
Testing Environment:
Hardware: Romley-EP platform
Xen version: latest upstream
Linux kernel: 3.4-RC6
Guest vCPU number: 8
NIC: Intel 82599 (10GB bandwidth)
In 'kernel build' testing in guest:
Command line | performance gain
make -j 4 | 3.81%
make -j 8 | 0.37%
make -j 16 | -0.52%In 'netperf' testing, we tested TCP_STREAM with default socket size 16384 byte as large packet and 64 byte as small packet.
I used several clients to add networking pressure, then 'netperf' server automatically generated several threads to response them.
I also used large-size packet and small-size packet in the testing.
Packet size | Thread number | performance gain 16384 bytes | 4 | 0.02% 16384 bytes | 8 | 2.21% 16384 bytes | 16 | 2.04% 64 bytes | 4 | 1.07% 64 bytes | 8 | 3.31% 64 bytes | 16 | 0.71%
This patch also fold a flush_tlb_mm_range() fixing in 'make allnoconfig' , that reported by Tetsuo Handa. Thanks!
--- arch/x86/include/asm/tlb.h | 9 +++- arch/x86/include/asm/tlbflush.h | 17 +++++- arch/x86/mm/tlb.c | 112 ++++++++++++++++----------------------- 3 files changed, 68 insertions(+), 70 deletions(-)
arch/x86/include/asm/tlb.h +8 -1
@@ -4,7 +4,14 @@#define tlb_start_vma (tlb, vma) do { } while (0)#define tlb_end_vma (tlb, vma) do { } while (0)#define __tlb_remove_tlb_entry (tlb, ptep, address) do { } while (0) -#define tlb_flush (tlb) flush_tlb_mm((tlb)->mm) + +#define tlb_flush (tlb) \ +{ \ + if (tlb->fullmm == 0) \ + flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end, 0UL); \ + else \ + flush_tlb_mm_range(tlb->mm, 0UL, TLB_FLUSH_ALL, 0UL); \ +}#include <asm-generic/tlb.h>
arch/x86/include/asm/tlbflush.h +14 -3
@@ -105,6 +105,13 @@ static inline void flush_tlb_range(struct vm_area_struct *vma,__flush_tlb (); } +static inline void flush_tlb_mm_range (struct mm_struct *mm, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (mm == current->active_mm) +__flush_tlb (); +} + static inline void native_flush_tlb_others(const struct cpumask *cpumask, struct mm_struct *mm, unsigned long start,
@@ -122,12 +129,16 @@ static inline void reset_lazy_tlbstate(void)#define local_flush_tlb () __flush_tlb() +#define flush_tlb_mm (mm) flush_tlb_mm_range(mm, 0UL, TLB_FLUSH_ALL, 0UL) + +#define flush_tlb_range (vma, start, end) \ + flush_tlb_mm_range(vma->vm_mm, start, end, vma->vm_flags) +extern void flush_tlb_all (void );extern void flush_tlb_current_task (void ); -extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); -extern void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end); +extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start, +unsigned long end,unsigned long vmflag);#define flush_tlb () flush_tlb_current_task()
arch/x86/mm/tlb.c +46 -66
137 lines not on this page · raw message
Signature · 1 line
1.7.5.4
H. Peter Anvin
reviewerRe: [PATCH v10 7/9] x86/tlb: enable tlb flush range support for x86
Separate is better. When I say clean patch I mean in a separate email so git am can process it.
Quoted 300 lines · Alex Shi
Quoted 10 lines · H. Peter Anvin
Quoted 4 lines · Alex Shi
Sure, it is a bug, the fix had sent:
https://lkml.org/lkml/2012/7/6/350Could you please re-send that as a clean patch?
-hpa
Since, it has not impact for the serial left patches, and linux-next has not merge this patchset. I folded this patch into original. Is that ok, or need a separated one?
===
From2e6117dfda5b323261e959bb5faf778cbe4b3c64Mon Sep 17 00:00:00 2001
From: Alex Shi <[email protected]>
Date: Mon, 25 Jun 2012 11:06:46 +0800
Subject: [PATCH 7/9] x86/tlb: enable tlb flush range support for x86Not every
tlb_flushexecution moment is really need to evacuate all TLB entries, like in munmap, just few 'invlpg' is better for whole process performance, since it leaves most of TLB entries for later accessing.This patch also rewrite
flush_tlb_rangefor 2 purposes:
1, split it out to getflush_blt_mm_rangefunction.
2, clean up to reduce line breaking, thanks for Borislav's input.My micro benchmark 'mummap' http://lkml.org/lkml/2012/5/17/59
show that the random memory access on other CPU has 0~50% speed up on a 2P * 4cores * HT NHM EP while do 'munmap'.Thanks Yongjie's testing on this patch:
-------------
I used Linux 3.4-RC6 w/ and w/o his patches as Xen dom0 and guest kernel.
After running two benchmarks in Xen HVM guest, I found his patches brought about 1%~3% performance gain in 'kernel build' and 'netperf' testing, though the performance gain was not very stable in 'kernel build' testing.Some detailed testing results are below.
Testing Environment:
Hardware: Romley-EP platform
Xen version: latest upstream
Linux kernel: 3.4-RC6
Guest vCPU number: 8
NIC: Intel 82599 (10GB bandwidth)In 'kernel build' testing in guest:
Command line | performance gain make -j 4 | 3.81% make -j 8 | 0.37% make -j 16 | -0.52%In 'netperf' testing, we tested
TCP_STREAMwith default socket size 16384 byte as large packet and 64 byte as small packet. I used several clients to add networking pressure, then 'netperf' server
automatically generated several threads to response them. I also used large-size packet and small-size packet in the testing.Packet size | Thread number | performance gain 16384 bytes | 4 | 0.02% 16384 bytes | 8 | 2.21% 16384 bytes | 16 | 2.04% 64 bytes | 4 | 1.07% 64 bytes | 8 | 3.31% 64 bytes | 16 | 0.71%This patch also fold a
flush_tlb_mm_range()fixing in 'make allnoconfig'
, that reported by Tetsuo Handa. Thanks!Signed-off-by Alex Shi <[email protected]>Tested-by Ren, Yongjie <[email protected]>---
arch/x86/include/asm/tlb.h | 9 +++- arch/x86/include/asm/tlbflush.h | 17 +++++- arch/x86/mm/tlb.c | 112 ++++++++++++++++----------------------- 3 files changed, 68 insertions(+), 70 deletions(-)arch/x86/include/asm/tlb.h +8
-1@@ -4,7 +4,14 @@#define tlb_start_vma (tlb, vma) do { } while (0)#define tlb_end_vma (tlb, vma) do { } while (0)#define __tlb_remove_tlb_entry (tlb, ptep, address) do { } while (0) -#define tlb_flush (tlb) flush_tlb_mm((tlb)->mm) + +#define tlb_flush (tlb) \ +{ \ + if (tlb->fullmm == 0) \ + flush_tlb_mm_range(tlb->mm, tlb->start, tlb->end, 0UL); \ + else \ + flush_tlb_mm_range(tlb->mm, 0UL, TLB_FLUSH_ALL, 0UL); \ +}#include <asm-generic/tlb.h> arch/x86/include/asm/tlbflush.h +7
-0@@ -105,6 +105,13 @@ static inline void flush_tlb_range(structvm_area_struct *vma,__flush_tlb (); } +static inline void flush_tlb_mm_range (struct mm_struct *mm, +unsigned long start,unsigned long end,unsigned long vmflag) +{ +if (mm == current->active_mm) +__flush_tlb (); +} +static inline void native_flush_tlb_others(const struct cpumask *cpumask,
structmm_struct*mm, unsigned long start,arch/x86/include/asm/tlbflush.h +7
-3@@ -122,12 +129,16 @@ static inline void reset_lazy_tlbstate(void)#define local_flush_tlb () __flush_tlb() +#define flush_tlb_mm (mm) flush_tlb_mm_range(mm, 0UL, TLB_FLUSH_ALL, 0UL) + +#define flush_tlb_range (vma, start, end) \ + flush_tlb_mm_range(vma->vm_mm, start, end, vma->vm_flags) +extern void flush_tlb_all (void );extern void flush_tlb_current_task (void ); -extern void flush_tlb_mm (struct mm_struct *);extern void flush_tlb_page (struct vm_area_struct *,unsigned long ); -extern void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end); +extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start, +unsigned long end,unsigned long vmflag);#define
flush_tlb()flush_tlb_current_task()arch/x86/mm/tlb.c +46
-66@@ -301,23 +301,10 @@ void flush_tlb_current_task(void)preempt_enable (); } -void flush_tlb_mm (struct mm_struct *mm) -{ -preempt_disable (); - -if (current->active_mm == mm) { -if (current->mm) -local_flush_tlb (); -else -leave_mm (smp_processor_id ()); - } -if (cpumask_any_but (mm_cpumask (mm),smp_processor_id ()) < nr_cpu_ids) -flush_tlb_others (mm_cpumask (mm), mm,0UL ,TLB_FLUSH_ALL ); - -preempt_enable (); -} - -#ifdef CONFIG_TRANSPARENT_HUGEPAGE +/* +* It can find out the THP large page, or +* HUGETLB page in tlb_flush when THP disabled +*/ static inline unsigned long has_large_page (struct mm_struct *mm,unsigned long start,unsigned long end) {@@ -339,68 +326,61 @@ static inline unsigned long has_large_page(struct mm_struct *mm, }return 0 ; } -#else -static inline unsigned long has_large_page (struct mm_struct *mm, -unsigned long start,unsigned long end) -{ -return 0 ; -} -#endif -void flush_tlb_range (struct vm_area_struct *vma, -unsigned long start,unsigned long end) -{ -struct mm_struct *mm; -if (vma->vm_flags &VM_HUGETLB || tlb_flushall_shift ==-1 ) { -flush_all: -flush_tlb_mm (vma->vm_mm); -return ; - } +void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start, +unsigned long end,unsigned long vmflag) +{ +unsigned long addr; +unsigned act_entries, tlb_entries =0 ;preempt_disable (); - mm = vma->vm_mm; -if (current->active_mm == mm) { -if (current->mm) { -unsigned long addr, vmflag = vma->vm_flags; -unsigned act_entries, tlb_entries =0 ; +if (current->active_mm != mm) + goto flush_all; -if (vmflag &VM_EXEC ) - tlb_entries = tlb_lli_4k[ENTRIES ]; -else - tlb_entries = tlb_lld_4k[ENTRIES ]; - - act_entries = tlb_entries > mm->total_vm ? - mm->total_vm : tlb_entries; +if (!current->mm) { +leave_mm (smp_processor_id ()); + goto flush_all; + } -if ((end - start) >>PAGE_SHIFT > - act_entries >> tlb_flushall_shift) -local_flush_tlb (); -else { -if (has_large_page (mm, start, end)) { -preempt_enable (); - goto flush_all; - } -for (addr = start; addr < end; - addr +=PAGE_SIZE ) -__flush_tlb_single (addr); +if (end ==TLB_FLUSH_ALL || tlb_flushall_shift ==-1 + || vmflag ==VM_HUGETLB ) { +local_flush_tlb (); + goto flush_all; + } -if (cpumask_any_but (mm_cpumask (mm), -smp_processor_id ()) < nr_cpu_ids) -flush_tlb_others (mm_cpumask (mm), mm, - start, end); -preempt_enable (); -return ; - } - }else { -leave_mm (smp_processor_id ()); +/* In modern CPU, last level tlb used for both data/ins */ +if (vmflag &VM_EXEC ) + tlb_entries = tlb_lli_4k[ENTRIES ]; +else + tlb_entries = tlb_lld_4k[ENTRIES ]; +/* Assume all of TLB entries was occupied by this task */ + act_entries = mm->total_vm > tlb_entries ? tlb_entries : mm->total_vm; + +/* tlb_flushall_shift is on balance point, details in commit log */ +if ((end - start) >>PAGE_SHIFT > act_entries >> tlb_flushall_shift) +local_flush_tlb (); +else { +if (has_large_page (mm, start, end)) { +local_flush_tlb (); + goto flush_all; } +/* flush range by one by one 'invlpg' */ +for (addr = start; addr < end; addr +=PAGE_SIZE ) +__flush_tlb_single (addr); + +if (cpumask_any_but (mm_cpumask (mm), +smp_processor_id ()) < nr_cpu_ids) +flush_tlb_others (mm_cpumask (mm), mm, start, end); +preempt_enable (); +return ; } + +flush_all:if (cpumask_any_but (mm_cpumask (mm),smp_processor_id ()) < nr_cpu_ids)flush_tlb_others (mm_cpumask (mm), mm,0UL ,TLB_FLUSH_ALL );preempt_enable (); } -void flush_tlb_page (struct vm_area_struct *vma,unsigned long start){ struct mm_struct *mm = vma->vm_mm;Signature · 1 line
1.7.5.4
Signature · 1 line
Sent from my mobile phone. Please excuse brevity and lack of formatting.
PATCH v10 8/9 x86/tlb: replace INVALIDATE_TLB_VECTOR by CALL_FUNCTION_VECTOR
In reply to Alex ShiThere are 32 INVALIDATE_TLB_VECTOR now in kernel. That is quite big amount of vector in IDT. But it is still not enough, since modern x86 sever has more cpu number. That still causes heavy lock contention in TLB flushing.
The patch using generic smp call function to replace it. That saved 32 vector number in IDT, and resolved the lock contention in TLB flushing on large system.
In the NHM EX machine 4P * 8cores * HT = 64 CPUs, hackbench pthread has 3% performance increase.
--- arch/x86/include/asm/entry_arch.h | 9 -- arch/x86/include/asm/irq_vectors.h | 11 -- arch/x86/kernel/entry_64.S | 18 --- arch/x86/kernel/irqinit.c | 73 ----------- arch/x86/mm/tlb.c | 238 +++++++----------------------------- 5 files changed, 45 insertions(+), 304 deletions(-)
arch/x86/include/asm/entry_arch.h +0 -9
@@ -15,15 +15,6 @@ BUILD_INTERRUPT(call_function_interrupt,CALL_FUNCTION_VECTOR) BUILD_INTERRUPT(call_function_single_interrupt,CALL_FUNCTION_SINGLE_VECTOR) BUILD_INTERRUPT(irq_move_cleanup_interrupt,IRQ_MOVE_CLEANUP_VECTOR) BUILD_INTERRUPT(reboot_interrupt,REBOOT_VECTOR) - -.irp idx,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \ -16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 -.if NUM_INVALIDATE_TLB_VECTORS > \idx -BUILD_INTERRUPT3(invalidate_interrupt\idx, - (INVALIDATE_TLB_VECTOR_START)+\idx, - smp_invalidate_interrupt) -.endif -.endr#endif BUILD_INTERRUPT (x86_platform_ipi,X86_PLATFORM_IPI_VECTOR )
arch/x86/include/asm/irq_vectors.h +0 -11
@@ -119,17 +119,6 @@*/ #define LOCAL_TIMER_VECTOR 0xef -/* up to 32 vectors used for spreading out TLB flushes: */ -#if NR_CPUS <=32 -# define NUM_INVALIDATE_TLB_VECTORS (NR_CPUS) -#else -# define NUM_INVALIDATE_TLB_VECTORS (32) -#endif - -#define INVALIDATE_TLB_VECTOR_END (0xee) -#define INVALIDATE_TLB_VECTOR_START \ - (INVALIDATE_TLB_VECTOR_END-NUM_INVALIDATE_TLB_VECTORS+1) -#define NR_VECTORS 256#define FPU_IRQ 13
arch/x86/kernel/entry_64.S +0 -18
@@ -1048,24 +1048,6 @@ apicinterrupt LOCAL_TIMER_VECTOR \ apicinterrupt X86_PLATFORM_IPI_VECTOR \ x86_platform_ipi smp_x86_platform_ipi -#ifdef CONFIG_SMP - ALIGN - INTR_FRAME -.irp idx,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \ - 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 -.if NUM_INVALIDATE_TLB_VECTORS > \idx -ENTRY(invalidate_interrupt\idx) - pushq_cfi $~(INVALIDATE_TLB_VECTOR_START+\idx) - jmp .Lcommon_invalidate_interrupt0 - CFI_ADJUST_CFA_OFFSET -8 -END(invalidate_interrupt\idx) -.endif -.endr - CFI_ENDPROC -apicinterrupt INVALIDATE_TLB_VECTOR_START, \ - invalidate_interrupt0, smp_invalidate_interrupt -#endif - apicinterrupt THRESHOLD_APIC_VECTOR \ threshold_interrupt smp_threshold_interrupt apicinterrupt THERMAL_APIC_VECTOR \
arch/x86/kernel/irqinit.c +0 -73
79 lines not on this page · raw message
arch/x86/mm/tlb.c +47 -195
295 lines not on this page · raw message
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: replace INVALIDATE_TLB_VECTOR by CALL_FUNCTION_VECTOR
Commit-ID: 52aec3308db85f4e9f5c8b9f5dc4fbd0138c6fa4 Gitweb: http://git.kernel.org/tip/52aec3308db85f4e9f5c8b9f5dc4fbd0138c6fa4 Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:23 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:13 -0700
x86/tlb: replace INVALIDATE_TLB_VECTOR by CALL_FUNCTION_VECTOR
There are 32 INVALIDATE_TLB_VECTOR now in kernel. That is quite big amount of vector in IDT. But it is still not enough, since modern x86 sever has more cpu number. That still causes heavy lock contention in TLB flushing.
The patch using generic smp call function to replace it. That saved 32 vector number in IDT, and resolved the lock contention in TLB flushing on large system.
In the NHM EX machine 4P * 8cores * HT = 64 CPUs, hackbench pthread has 3% performance increase.
--- arch/x86/include/asm/entry_arch.h | 9 -- arch/x86/include/asm/irq_vectors.h | 11 -- arch/x86/kernel/entry_64.S | 18 --- arch/x86/kernel/irqinit.c | 73 ----------- arch/x86/mm/tlb.c | 238 +++++++----------------------------- 5 files changed, 45 insertions(+), 304 deletions(-)
arch/x86/include/asm/entry_arch.h +0 -9
@@ -15,15 +15,6 @@ BUILD_INTERRUPT(call_function_interrupt,CALL_FUNCTION_VECTOR) BUILD_INTERRUPT(call_function_single_interrupt,CALL_FUNCTION_SINGLE_VECTOR) BUILD_INTERRUPT(irq_move_cleanup_interrupt,IRQ_MOVE_CLEANUP_VECTOR) BUILD_INTERRUPT(reboot_interrupt,REBOOT_VECTOR) - -.irp idx,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \ -16 ,17 ,18 ,19 ,20 ,21 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 -.if NUM_INVALIDATE_TLB_VECTORS > \idx -BUILD_INTERRUPT3(invalidate_interrupt\idx, - (INVALIDATE_TLB_VECTOR_START)+\idx, - smp_invalidate_interrupt) -.endif -.endr#endif BUILD_INTERRUPT (x86_platform_ipi,X86_PLATFORM_IPI_VECTOR )
arch/x86/include/asm/irq_vectors.h +0 -11
@@ -119,17 +119,6 @@*/ #define LOCAL_TIMER_VECTOR 0xef -/* up to 32 vectors used for spreading out TLB flushes: */ -#if NR_CPUS <=32 -# define NUM_INVALIDATE_TLB_VECTORS (NR_CPUS) -#else -# define NUM_INVALIDATE_TLB_VECTORS (32) -#endif - -#define INVALIDATE_TLB_VECTOR_END (0xee) -#define INVALIDATE_TLB_VECTOR_START \ - (INVALIDATE_TLB_VECTOR_END-NUM_INVALIDATE_TLB_VECTORS+1) -#define NR_VECTORS 256#define FPU_IRQ 13
arch/x86/kernel/entry_64.S +0 -18
@@ -1048,24 +1048,6 @@ apicinterrupt LOCAL_TIMER_VECTOR \ apicinterrupt X86_PLATFORM_IPI_VECTOR \ x86_platform_ipi smp_x86_platform_ipi -#ifdef CONFIG_SMP - ALIGN - INTR_FRAME -.irp idx,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \ - 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 -.if NUM_INVALIDATE_TLB_VECTORS > \idx -ENTRY(invalidate_interrupt\idx) - pushq_cfi $~(INVALIDATE_TLB_VECTOR_START+\idx) - jmp .Lcommon_invalidate_interrupt0 - CFI_ADJUST_CFA_OFFSET -8 -END(invalidate_interrupt\idx) -.endif -.endr - CFI_ENDPROC -apicinterrupt INVALIDATE_TLB_VECTOR_START, \ - invalidate_interrupt0, smp_invalidate_interrupt -#endif - apicinterrupt THRESHOLD_APIC_VECTOR \ threshold_interrupt smp_threshold_interrupt apicinterrupt THERMAL_APIC_VECTOR \
arch/x86/kernel/irqinit.c +0 -73
79 lines not on this page · raw message
arch/x86/mm/tlb.c +47 -195
295 lines not on this page · raw message
PATCH v10 9/9 x86/tlb: do flush_tlb_kernel_range by 'invlpg'
In reply to Alex ShiThis patch do flush_tlb_kernel_range by 'invlpg'. The performance pay and gain was analyzed in previous patch
(x86/flush_tlb: try flush_tlb_single one by one in flush_tlb_range).
In the testing: http://lkml.org/lkml/2012/6/21/10
The pay is mostly covered by long kernel path, but the gain is still quite clear, memory access in user APP can increase 30+% when kernel execute this funtion.
--- arch/x86/include/asm/tlbflush.h | 13 +++++++------ arch/x86/mm/tlb.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 6 deletions(-)
arch/x86/include/asm/tlbflush.h +7 -6
@@ -123,6 +123,12 @@ static inline void reset_lazy_tlbstate(void) { } +static inline void flush_tlb_kernel_range (unsigned long start, +unsigned long end) +{ +flush_tlb_all (); +} +#else /* SMP */ #include <asm/smp.h>
@@ -139,6 +145,7 @@ extern void flush_tlb_current_task(void);extern void flush_tlb_page (struct vm_area_struct *,unsigned long );extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start,unsigned long end,unsigned long vmflag); +extern void flush_tlb_kernel_range (unsigned long start,unsigned long end);#define flush_tlb () flush_tlb_current_task()
@@ -168,10 +175,4 @@ static inline void reset_lazy_tlbstate(void) native_flush_tlb_others(mask, mm, start, end)#endif -static inline void flush_tlb_kernel_range (unsigned long start, -unsigned long end) -{ -flush_tlb_all (); -} -#endif /* _ASM_X86_TLBFLUSH_H */
arch/x86/mm/tlb.c +30 -0
@@ -264,6 +264,36 @@ void flush_tlb_all(void)on_each_cpu (do_flush_tlb_all,NULL ,1 ); } +static void do_kernel_range_flush (void *info) +{ +struct flush_tlb_info *f = info; +unsigned long addr; + +/* flush range by one by one 'invlpg' */ +for (addr = f->flush_start; addr < f->flush_end; addr +=PAGE_SIZE ) +__flush_tlb_single (addr); +} + +void flush_tlb_kernel_range (unsigned long start,unsigned long end) +{ +unsigned act_entries; +struct flush_tlb_info info; + +/* In modern CPU, last level tlb used for both data/ins */ + act_entries = tlb_lld_4k[ENTRIES ]; + +/* Balance as user space task's flush, a bit conservative */ +if (end ==TLB_FLUSH_ALL || tlb_flushall_shift ==-1 || + (end - start) >>PAGE_SHIFT > act_entries >> tlb_flushall_shift) + +on_each_cpu (do_flush_tlb_all,NULL ,1 ); +else { + info.flush_start = start; + info.flush_end = end; +on_each_cpu (do_kernel_range_flush, &info,1 ); + } +} +#ifdef CONFIG_DEBUG_TLBFLUSH static ssize_t tlbflush_read_file (struct file *file,char __user *user_buf,size_t count,loff_t *ppos)
Signature · 1 line
1.7.5.4
[tip:x86/mm] x86/tlb: do flush_tlb_kernel_range by 'invlpg'
Commit-ID: effee4b9b3b0aa5770bcd98de5f672b05b27703c Gitweb: http://git.kernel.org/tip/effee4b9b3b0aa5770bcd98de5f672b05b27703c Author: Alex Shi <[email protected]> AuthorDate: Thu, 28 Jun 2012 09:02:24 +0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Wed, 27 Jun 2012 19:29:14 -0700
x86/tlb: do flush_tlb_kernel_range by 'invlpg'
This patch do flush_tlb_kernel_range by 'invlpg'. The performance pay and gain was analyzed in previous patch
(x86/flush_tlb: try flush_tlb_single one by one in flush_tlb_range).
In the testing: http://lkml.org/lkml/2012/6/21/10
The pay is mostly covered by long kernel path, but the gain is still quite clear, memory access in user APP can increase 30+% when kernel execute this funtion.
--- arch/x86/include/asm/tlbflush.h | 13 +++++++------ arch/x86/mm/tlb.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 6 deletions(-)
arch/x86/include/asm/tlbflush.h +7 -6
@@ -123,6 +123,12 @@ static inline void reset_lazy_tlbstate(void) { } +static inline void flush_tlb_kernel_range (unsigned long start, +unsigned long end) +{ +flush_tlb_all (); +} +#else /* SMP */ #include <asm/smp.h>
@@ -139,6 +145,7 @@ extern void flush_tlb_current_task(void);extern void flush_tlb_page (struct vm_area_struct *,unsigned long );extern void flush_tlb_mm_range (struct mm_struct *mm,unsigned long start,unsigned long end,unsigned long vmflag); +extern void flush_tlb_kernel_range (unsigned long start,unsigned long end);#define flush_tlb () flush_tlb_current_task()
@@ -168,10 +175,4 @@ static inline void reset_lazy_tlbstate(void) native_flush_tlb_others(mask, mm, start, end)#endif -static inline void flush_tlb_kernel_range (unsigned long start, -unsigned long end) -{ -flush_tlb_all (); -} -#endif /* _ASM_X86_TLBFLUSH_H */
arch/x86/mm/tlb.c +30 -0
@@ -264,6 +264,36 @@ void flush_tlb_all(void)on_each_cpu (do_flush_tlb_all,NULL ,1 ); } +static void do_kernel_range_flush (void *info) +{ +struct flush_tlb_info *f = info; +unsigned long addr; + +/* flush range by one by one 'invlpg' */ +for (addr = f->flush_start; addr < f->flush_end; addr +=PAGE_SIZE ) +__flush_tlb_single (addr); +} + +void flush_tlb_kernel_range (unsigned long start,unsigned long end) +{ +unsigned act_entries; +struct flush_tlb_info info; + +/* In modern CPU, last level tlb used for both data/ins */ + act_entries = tlb_lld_4k[ENTRIES ]; + +/* Balance as user space task's flush, a bit conservative */ +if (end ==TLB_FLUSH_ALL || tlb_flushall_shift ==-1 || + (end - start) >>PAGE_SHIFT > act_entries >> tlb_flushall_shift) + +on_each_cpu (do_flush_tlb_all,NULL ,1 ); +else { + info.flush_start = start; + info.flush_end = end; +on_each_cpu (do_kernel_range_flush, &info,1 ); + } +} +#ifdef CONFIG_DEBUG_TLBFLUSH static ssize_t tlbflush_read_file (struct file *file,char __user *user_buf,size_t count,loff_t *ppos)