path: root/mm
diff options
authorNick Piggin <>2008-07-25 19:45:24 -0700
committerLinus Torvalds <>2008-07-26 12:00:06 -0700
commit8174c430e445a93016ef18f717fe570214fa38bf (patch)
treef1b4426eae7401425e9102c7b3e141be86f0930c /mm
parent21cc199baa815d7b3f1ace4be20b9558cbddc00f (diff)
x86: lockless get_user_pages_fast()
Implement get_user_pages_fast without locking in the fastpath on x86. Do an optimistic lockless pagetable walk, without taking mmap_sem or any page table locks or even mmap_sem. Page table existence is guaranteed by turning interrupts off (combined with the fact that we're always looking up the current mm, means we can do the lockless page table walk within the constraints of the TLB shootdown design). Basically we can do this lockless pagetable walk in a similar manner to the way the CPU's pagetable walker does not have to take any locks to find present ptes. This patch (combined with the subsequent ones to convert direct IO to use it) was found to give about 10% performance improvement on a 2 socket 8 core Intel Xeon system running an OLTP workload on DB2 v9.5 "To test the effects of the patch, an OLTP workload was run on an IBM x3850 M2 server with 2 processors (quad-core Intel Xeon processors at 2.93 GHz) using IBM DB2 v9.5 running Linux 2.6.24rc7 kernel. Comparing runs with and without the patch resulted in an overall performance benefit of ~9.8%. Correspondingly, oprofiles showed that samples from __up_read and __down_read routines that is seen during thread contention for system resources was reduced from 2.8% down to .05%. Monitoring the /proc/vmstat output from the patched run showed that the counter for fast_gup contained a very high number while the fast_gup_slow value was zero." (fast_gup is the old name for get_user_pages_fast, fast_gup_slow is a counter we had for the number of times the slowpath was invoked). The main reason for the improvement is that DB2 has multiple threads each issuing direct-IO. Direct-IO uses get_user_pages, and thus the threads contend the mmap_sem cacheline, and can also contend on page table locks. I would anticipate larger performance gains on larger systems, however I think DB2 uses an adaptive mix of threads and processes, so it could be that thread contention remains pretty constant as machine size increases. In which case, we stuck with "only" a 10% gain. The downside of using get_user_pages_fast is that if there is not a pte with the correct permissions for the access, we end up falling back to get_user_pages and so the get_user_pages_fast is a bit of extra work. However this should not be the common case in most performance critical code. [ coding-style fixes] [ build fix] [ Kconfig fix] [ Makefile fix/cleanup] [ warning fix] Signed-off-by: Nick Piggin <> Cc: Dave Kleikamp <> Cc: Andy Whitcroft <> Cc: Ingo Molnar <> Cc: Thomas Gleixner <> Cc: Andi Kleen <> Cc: Dave Kleikamp <> Cc: Badari Pulavarty <> Cc: Zach Brown <> Cc: Jens Axboe <> Reviewed-by: Peter Zijlstra <> Signed-off-by: Andrew Morton <> Signed-off-by: Linus Torvalds <>
Diffstat (limited to 'mm')
1 files changed, 3 insertions, 0 deletions
diff --git a/mm/Kconfig b/mm/Kconfig
index aa799007a11..efee5d379df 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -77,6 +77,9 @@ config FLAT_NODE_MEM_MAP
def_bool y
depends on !SPARSEMEM
+ bool
# Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's
# to represent different areas of memory. This variable allows