diff for duplicates of <20130808084505.31EACE0090@blue.fi.intel.com> diff --git a/a/1.txt b/N1/1.txt index 60b0c29..8c66328 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -4,273 +4,3 @@ Kirill A. Shutemov wrote: Okay, I've got it. We share one 2nd level node. Patch is below. Please review. - ->From 35ba5687ea7aea98645da34ddd0be01a9de8b32d Mon Sep 17 00:00:00 2001 -From: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com> -Date: Wed, 9 Jan 2013 13:25:47 +0200 -Subject: [PATCH] radix-tree: implement preload for multiple contiguous - elements - -The radix tree is variable-height, so an insert operation not only has -to build the branch to its corresponding item, it also has to build the -branch to existing items if the size has to be increased (by -radix_tree_extend). - -The worst case is a zero height tree with just a single item at index 0, -and then inserting an item at index ULONG_MAX. This requires 2 new branches -of RADIX_TREE_MAX_PATH size to be created, with only the root node shared. - -Radix tree is usually protected by spin lock. It means we want to -pre-allocate required memory before taking the lock. - -Currently radix_tree_preload() only guarantees enough nodes to insert -one element. It's a hard limit. For transparent huge page cache we want -to insert HPAGE_PMD_NR (512 on x86-64) entries to address_space at once. - -This patch introduces radix_tree_preload_count(). It allows to -preallocate nodes enough to insert a number of *contiguous* elements. -The feature costs about 9KiB per-CPU on x86_64, details below. - -Preload uses per-CPU array to store nodes. The total cost of preload is -"array size" * sizeof(void*) * NR_CPUS. We want to increase array size -to be able to handle 512 entries at once. - -Size of array depends on system bitness and on RADIX_TREE_MAP_SHIFT. - -We have three possible RADIX_TREE_MAP_SHIFT: - - #ifdef __KERNEL__ - #define RADIX_TREE_MAP_SHIFT (CONFIG_BASE_SMALL ? 4 : 6) - #else - #define RADIX_TREE_MAP_SHIFT 3 /* For more stressful testing */ - #endif - -We are not going to use transparent huge page cache on small machines or -in userspace, so we are interested in RADIX_TREE_MAP_SHIFT=6. - -On 64-bit system old array size is 21, new is 37. Per-CPU feature -overhead is - for preload array: - (37 - 21) * sizeof(void*) = 128 bytes - plus, if the preload array is full - (37 - 21) * sizeof(struct radix_tree_node) = 16 * 560 = 8960 bytes - total: 9088 bytes - -On 32-bit system old array size is 11, new is 22. Per-CPU feature -overhead is - for preload array: - (22 - 11) * sizeof(void*) = 44 bytes - plus, if the preload array is full - (22 - 11) * sizeof(struct radix_tree_node) = 11 * 296 = 3256 bytes - total: 3300 bytes - -Since only THP uses batched preload at the moment, we disable (set max -preload to 1) it if !CONFIG_TRANSPARENT_HUGEPAGE_PAGECACHE. This can be -changed in the future. - -Signed-off-by: Matthew Wilcox <willy@linux.intel.com> -Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> -Acked-by: Dave Hansen <dave.hansen@linux.intel.com> ---- - include/linux/radix-tree.h | 11 ++++++ - lib/radix-tree.c | 89 +++++++++++++++++++++++++++++++++++++++++----- - 2 files changed, 91 insertions(+), 9 deletions(-) - -diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h -index 4039407..3bf0b3e 100644 ---- a/include/linux/radix-tree.h -+++ b/include/linux/radix-tree.h -@@ -83,6 +83,16 @@ do { \ - (root)->rnode = NULL; \ - } while (0) - -+#ifdef CONFIG_TRANSPARENT_HUGEPAGE_PAGECACHE -+/* -+ * At the moment only THP uses preload for more then on item for batched -+ * pagecache manipulations. -+ */ -+#define RADIX_TREE_PRELOAD_NR 512 -+#else -+#define RADIX_TREE_PRELOAD_NR 1 -+#endif -+ - /** - * Radix-tree synchronization - * -@@ -232,6 +242,7 @@ unsigned long radix_tree_prev_hole(struct radix_tree_root *root, - unsigned long index, unsigned long max_scan); - int radix_tree_preload(gfp_t gfp_mask); - int radix_tree_maybe_preload(gfp_t gfp_mask); -+int radix_tree_maybe_preload_contig(unsigned size, gfp_t gfp_mask); - void radix_tree_init(void); - void *radix_tree_tag_set(struct radix_tree_root *root, - unsigned long index, unsigned int tag); -diff --git a/lib/radix-tree.c b/lib/radix-tree.c -index 7811ed3..980e4c4 100644 ---- a/lib/radix-tree.c -+++ b/lib/radix-tree.c -@@ -84,14 +84,54 @@ static struct kmem_cache *radix_tree_node_cachep; - * of RADIX_TREE_MAX_PATH size to be created, with only the root node shared. - * Hence: - */ --#define RADIX_TREE_PRELOAD_SIZE (RADIX_TREE_MAX_PATH * 2 - 1) -+#define RADIX_TREE_PRELOAD_MIN (RADIX_TREE_MAX_PATH * 2 - 1) -+ -+/* -+ * Inserting N contiguous items is more complex. To simplify calculation, let's -+ * limit N (validated in radix_tree_init()): -+ * - N is multiplier of RADIX_TREE_MAP_SIZE (or 1); -+ * - N <= number of items 2-level tree can contain: -+ * 1UL << (2 * RADIX_TREE_MAP_SHIFT). -+ * -+ * No limitation on insert index alignment. -+ * -+ * Then the worst case is tree with only one element at index 0 and we add N -+ * items where at least one index requires max tree high and we cross boundary -+ * between items in root node. -+ * -+ * Basically, at least one index is less then -+ * -+ * 1UL << ((RADIX_TREE_MAX_PATH - 1) * RADIX_TREE_MAP_SHIFT) -+ * -+ * and one is equal to. -+ * -+ * In this case we need: -+ * -+ * - RADIX_TREE_MAX_PATH nodes to build new path to item with index 0; -+ * - N / RADIX_TREE_MAP_SIZE + 1 nodes for last level nodes for new items: -+ * - +1 is for misalinged case; -+ * - 2 * (RADIX_TREE_MAX_PATH - 2) - 1 nodes to build path to last level nodes: -+ * - -2, because root node and last level nodes are already accounted); -+ * - -1, because one second level node is shared between item with index 0 -+ * and item below the boundary; -+ * -+ * Hence: -+ */ -+#if RADIX_TREE_PRELOAD_NR > 1 -+#define RADIX_TREE_PRELOAD_MAX \ -+ ( RADIX_TREE_MAX_PATH + \ -+ RADIX_TREE_PRELOAD_NR / RADIX_TREE_MAP_SIZE + 1 + \ -+ 2 * (RADIX_TREE_MAX_PATH - 2) - 1) -+#else -+#define RADIX_TREE_PRELOAD_MAX RADIX_TREE_PRELOAD_MIN -+#endif - - /* - * Per-cpu pool of preloaded nodes - */ - struct radix_tree_preload { - int nr; -- struct radix_tree_node *nodes[RADIX_TREE_PRELOAD_SIZE]; -+ struct radix_tree_node *nodes[RADIX_TREE_PRELOAD_MAX]; - }; - static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, }; - -@@ -263,29 +303,35 @@ radix_tree_node_free(struct radix_tree_node *node) - - /* - * Load up this CPU's radix_tree_node buffer with sufficient objects to -- * ensure that the addition of a single element in the tree cannot fail. On -- * success, return zero, with preemption disabled. On error, return -ENOMEM -+ * ensure that the addition of *contiguous* items in the tree cannot fail. -+ * On success, return zero, with preemption disabled. On error, return -ENOMEM - * with preemption not disabled. - * - * To make use of this facility, the radix tree must be initialised without - * __GFP_WAIT being passed to INIT_RADIX_TREE(). - */ --static int __radix_tree_preload(gfp_t gfp_mask) -+static int __radix_tree_preload_contig(unsigned size, gfp_t gfp_mask) - { - struct radix_tree_preload *rtp; - struct radix_tree_node *node; - int ret = -ENOMEM; -+ int preload_target = RADIX_TREE_PRELOAD_MIN + -+ DIV_ROUND_UP(size - 1, RADIX_TREE_MAP_SIZE); -+ -+ if (WARN_ONCE(size > RADIX_TREE_PRELOAD_NR, -+ "too large preload requested")) -+ return -ENOMEM; - - preempt_disable(); - rtp = &__get_cpu_var(radix_tree_preloads); -- while (rtp->nr < ARRAY_SIZE(rtp->nodes)) { -+ while (rtp->nr < preload_target) { - preempt_enable(); - node = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask); - if (node == NULL) - goto out; - preempt_disable(); - rtp = &__get_cpu_var(radix_tree_preloads); -- if (rtp->nr < ARRAY_SIZE(rtp->nodes)) -+ if (rtp->nr < preload_target) - rtp->nodes[rtp->nr++] = node; - else - kmem_cache_free(radix_tree_node_cachep, node); -@@ -308,7 +354,7 @@ int radix_tree_preload(gfp_t gfp_mask) - { - /* Warn on non-sensical use... */ - WARN_ON_ONCE(!(gfp_mask & __GFP_WAIT)); -- return __radix_tree_preload(gfp_mask); -+ return __radix_tree_preload_contig(1, gfp_mask); - } - EXPORT_SYMBOL(radix_tree_preload); - -@@ -320,13 +366,22 @@ EXPORT_SYMBOL(radix_tree_preload); - int radix_tree_maybe_preload(gfp_t gfp_mask) - { - if (gfp_mask & __GFP_WAIT) -- return __radix_tree_preload(gfp_mask); -+ return __radix_tree_preload_contig(1, gfp_mask); - /* Preloading doesn't help anything with this gfp mask, skip it */ - preempt_disable(); - return 0; - } - EXPORT_SYMBOL(radix_tree_maybe_preload); - -+int radix_tree_maybe_preload_contig(unsigned size, gfp_t gfp_mask) -+{ -+ if (gfp_mask & __GFP_WAIT) -+ return __radix_tree_preload_contig(size, gfp_mask); -+ /* Preloading doesn't help anything with this gfp mask, skip it */ -+ preempt_disable(); -+ return 0; -+} -+ - /* - * Return the maximum key which can be store into a - * radix tree with height HEIGHT. -@@ -1483,6 +1538,22 @@ static int radix_tree_callback(struct notifier_block *nfb, - - void __init radix_tree_init(void) - { -+ /* -+ * Restrictions on RADIX_TREE_PRELOAD_NR simplify RADIX_TREE_PRELOAD_MAX -+ * calculation, it's already complex enough: -+ * - it must be multiplier of RADIX_TREE_MAP_SIZE, otherwise we will -+ * have to round it up to next RADIX_TREE_MAP_SIZE multiplier and we -+ * don't win anything; -+ * - must be less then number of items 2-level tree can contain. -+ * It's easier to calculate number of internal nodes required -+ * this way. -+ */ -+ if (RADIX_TREE_PRELOAD_NR != 1) { -+ BUILD_BUG_ON(RADIX_TREE_PRELOAD_NR % RADIX_TREE_MAP_SIZE != 0); -+ BUILD_BUG_ON(RADIX_TREE_PRELOAD_NR > -+ 1UL << (2 * RADIX_TREE_MAP_SHIFT)); -+ } -+ - radix_tree_node_cachep = kmem_cache_create("radix_tree_node", - sizeof(struct radix_tree_node), 0, - SLAB_PANIC | SLAB_RECLAIM_ACCOUNT, --- -1.8.3.2 - --- - Kirill A. Shutemov - --- -To unsubscribe, send a message with 'unsubscribe linux-mm' in -the body to majordomo@kvack.org. For more info on Linux MM, -see: http://www.linux-mm.org/ . -Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> diff --git a/a/content_digest b/N1/content_digest index 888f7a3..a33bb8c 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -12,8 +12,7 @@ "To\0Jan Kara <jack@suse.cz>" Matthew Wilcox <willy@linux.intel.com> " Dave Hansen <dave@sr71.net>\0" - "Cc\0Jan Kara <jack@suse.cz>" - Kirill A. Shutemov <kirill.shutemov@linux.intel.com> + "Cc\0Kirill A. Shutemov <kirill.shutemov@linux.intel.com>" Andrea Arcangeli <aarcange@redhat.com> Andrew Morton <akpm@linux-foundation.org> Al Viro <viro@zeniv.linux.org.uk> @@ -34,276 +33,6 @@ "\n" "Okay, I've got it. We share one 2nd level node.\n" "\n" - "Patch is below. Please review.\n" - "\n" - ">From 35ba5687ea7aea98645da34ddd0be01a9de8b32d Mon Sep 17 00:00:00 2001\n" - "From: \"Kirill A. Shutemov\" <kirill.shutemov@linux.intel.com>\n" - "Date: Wed, 9 Jan 2013 13:25:47 +0200\n" - "Subject: [PATCH] radix-tree: implement preload for multiple contiguous\n" - " elements\n" - "\n" - "The radix tree is variable-height, so an insert operation not only has\n" - "to build the branch to its corresponding item, it also has to build the\n" - "branch to existing items if the size has to be increased (by\n" - "radix_tree_extend).\n" - "\n" - "The worst case is a zero height tree with just a single item at index 0,\n" - "and then inserting an item at index ULONG_MAX. This requires 2 new branches\n" - "of RADIX_TREE_MAX_PATH size to be created, with only the root node shared.\n" - "\n" - "Radix tree is usually protected by spin lock. It means we want to\n" - "pre-allocate required memory before taking the lock.\n" - "\n" - "Currently radix_tree_preload() only guarantees enough nodes to insert\n" - "one element. It's a hard limit. For transparent huge page cache we want\n" - "to insert HPAGE_PMD_NR (512 on x86-64) entries to address_space at once.\n" - "\n" - "This patch introduces radix_tree_preload_count(). It allows to\n" - "preallocate nodes enough to insert a number of *contiguous* elements.\n" - "The feature costs about 9KiB per-CPU on x86_64, details below.\n" - "\n" - "Preload uses per-CPU array to store nodes. The total cost of preload is\n" - "\"array size\" * sizeof(void*) * NR_CPUS. We want to increase array size\n" - "to be able to handle 512 entries at once.\n" - "\n" - "Size of array depends on system bitness and on RADIX_TREE_MAP_SHIFT.\n" - "\n" - "We have three possible RADIX_TREE_MAP_SHIFT:\n" - "\n" - " #ifdef __KERNEL__\n" - " #define RADIX_TREE_MAP_SHIFT\t(CONFIG_BASE_SMALL ? 4 : 6)\n" - " #else\n" - " #define RADIX_TREE_MAP_SHIFT\t3\t/* For more stressful testing */\n" - " #endif\n" - "\n" - "We are not going to use transparent huge page cache on small machines or\n" - "in userspace, so we are interested in RADIX_TREE_MAP_SHIFT=6.\n" - "\n" - "On 64-bit system old array size is 21, new is 37. Per-CPU feature\n" - "overhead is\n" - " for preload array:\n" - " (37 - 21) * sizeof(void*) = 128 bytes\n" - " plus, if the preload array is full\n" - " (37 - 21) * sizeof(struct radix_tree_node) = 16 * 560 = 8960 bytes\n" - " total: 9088 bytes\n" - "\n" - "On 32-bit system old array size is 11, new is 22. Per-CPU feature\n" - "overhead is\n" - " for preload array:\n" - " (22 - 11) * sizeof(void*) = 44 bytes\n" - " plus, if the preload array is full\n" - " (22 - 11) * sizeof(struct radix_tree_node) = 11 * 296 = 3256 bytes\n" - " total: 3300 bytes\n" - "\n" - "Since only THP uses batched preload at the moment, we disable (set max\n" - "preload to 1) it if !CONFIG_TRANSPARENT_HUGEPAGE_PAGECACHE. This can be\n" - "changed in the future.\n" - "\n" - "Signed-off-by: Matthew Wilcox <willy@linux.intel.com>\n" - "Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>\n" - "Acked-by: Dave Hansen <dave.hansen@linux.intel.com>\n" - "---\n" - " include/linux/radix-tree.h | 11 ++++++\n" - " lib/radix-tree.c | 89 +++++++++++++++++++++++++++++++++++++++++-----\n" - " 2 files changed, 91 insertions(+), 9 deletions(-)\n" - "\n" - "diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h\n" - "index 4039407..3bf0b3e 100644\n" - "--- a/include/linux/radix-tree.h\n" - "+++ b/include/linux/radix-tree.h\n" - "@@ -83,6 +83,16 @@ do {\t\t\t\t\t\t\t\t\t\\\n" - " \t(root)->rnode = NULL;\t\t\t\t\t\t\\\n" - " } while (0)\n" - " \n" - "+#ifdef CONFIG_TRANSPARENT_HUGEPAGE_PAGECACHE\n" - "+/*\n" - "+ * At the moment only THP uses preload for more then on item for batched\n" - "+ * pagecache manipulations.\n" - "+ */\n" - "+#define RADIX_TREE_PRELOAD_NR\t512\n" - "+#else\n" - "+#define RADIX_TREE_PRELOAD_NR\t1\n" - "+#endif\n" - "+\n" - " /**\n" - " * Radix-tree synchronization\n" - " *\n" - "@@ -232,6 +242,7 @@ unsigned long radix_tree_prev_hole(struct radix_tree_root *root,\n" - " \t\t\t\tunsigned long index, unsigned long max_scan);\n" - " int radix_tree_preload(gfp_t gfp_mask);\n" - " int radix_tree_maybe_preload(gfp_t gfp_mask);\n" - "+int radix_tree_maybe_preload_contig(unsigned size, gfp_t gfp_mask);\n" - " void radix_tree_init(void);\n" - " void *radix_tree_tag_set(struct radix_tree_root *root,\n" - " \t\t\tunsigned long index, unsigned int tag);\n" - "diff --git a/lib/radix-tree.c b/lib/radix-tree.c\n" - "index 7811ed3..980e4c4 100644\n" - "--- a/lib/radix-tree.c\n" - "+++ b/lib/radix-tree.c\n" - "@@ -84,14 +84,54 @@ static struct kmem_cache *radix_tree_node_cachep;\n" - " * of RADIX_TREE_MAX_PATH size to be created, with only the root node shared.\n" - " * Hence:\n" - " */\n" - "-#define RADIX_TREE_PRELOAD_SIZE (RADIX_TREE_MAX_PATH * 2 - 1)\n" - "+#define RADIX_TREE_PRELOAD_MIN (RADIX_TREE_MAX_PATH * 2 - 1)\n" - "+\n" - "+/*\n" - "+ * Inserting N contiguous items is more complex. To simplify calculation, let's\n" - "+ * limit N (validated in radix_tree_init()):\n" - "+ * - N is multiplier of RADIX_TREE_MAP_SIZE (or 1);\n" - "+ * - N <= number of items 2-level tree can contain:\n" - "+ * 1UL << (2 * RADIX_TREE_MAP_SHIFT).\n" - "+ *\n" - "+ * No limitation on insert index alignment.\n" - "+ *\n" - "+ * Then the worst case is tree with only one element at index 0 and we add N\n" - "+ * items where at least one index requires max tree high and we cross boundary\n" - "+ * between items in root node.\n" - "+ *\n" - "+ * Basically, at least one index is less then\n" - "+ *\n" - "+ * 1UL << ((RADIX_TREE_MAX_PATH - 1) * RADIX_TREE_MAP_SHIFT)\n" - "+ *\n" - "+ * and one is equal to.\n" - "+ *\n" - "+ * In this case we need:\n" - "+ *\n" - "+ * - RADIX_TREE_MAX_PATH nodes to build new path to item with index 0;\n" - "+ * - N / RADIX_TREE_MAP_SIZE + 1 nodes for last level nodes for new items:\n" - "+ * - +1 is for misalinged case;\n" - "+ * - 2 * (RADIX_TREE_MAX_PATH - 2) - 1 nodes to build path to last level nodes:\n" - "+ * - -2, because root node and last level nodes are already accounted);\n" - "+ * - -1, because one second level node is shared between item with index 0\n" - "+ * and item below the boundary;\n" - "+ *\n" - "+ * Hence:\n" - "+ */\n" - "+#if RADIX_TREE_PRELOAD_NR > 1\n" - "+#define RADIX_TREE_PRELOAD_MAX \\\n" - "+\t( RADIX_TREE_MAX_PATH + \\\n" - "+\t RADIX_TREE_PRELOAD_NR / RADIX_TREE_MAP_SIZE + 1 + \\\n" - "+\t 2 * (RADIX_TREE_MAX_PATH - 2) - 1)\n" - "+#else\n" - "+#define RADIX_TREE_PRELOAD_MAX RADIX_TREE_PRELOAD_MIN\n" - "+#endif\n" - " \n" - " /*\n" - " * Per-cpu pool of preloaded nodes\n" - " */\n" - " struct radix_tree_preload {\n" - " \tint nr;\n" - "-\tstruct radix_tree_node *nodes[RADIX_TREE_PRELOAD_SIZE];\n" - "+\tstruct radix_tree_node *nodes[RADIX_TREE_PRELOAD_MAX];\n" - " };\n" - " static DEFINE_PER_CPU(struct radix_tree_preload, radix_tree_preloads) = { 0, };\n" - " \n" - "@@ -263,29 +303,35 @@ radix_tree_node_free(struct radix_tree_node *node)\n" - " \n" - " /*\n" - " * Load up this CPU's radix_tree_node buffer with sufficient objects to\n" - "- * ensure that the addition of a single element in the tree cannot fail. On\n" - "- * success, return zero, with preemption disabled. On error, return -ENOMEM\n" - "+ * ensure that the addition of *contiguous* items in the tree cannot fail.\n" - "+ * On success, return zero, with preemption disabled. On error, return -ENOMEM\n" - " * with preemption not disabled.\n" - " *\n" - " * To make use of this facility, the radix tree must be initialised without\n" - " * __GFP_WAIT being passed to INIT_RADIX_TREE().\n" - " */\n" - "-static int __radix_tree_preload(gfp_t gfp_mask)\n" - "+static int __radix_tree_preload_contig(unsigned size, gfp_t gfp_mask)\n" - " {\n" - " \tstruct radix_tree_preload *rtp;\n" - " \tstruct radix_tree_node *node;\n" - " \tint ret = -ENOMEM;\n" - "+\tint preload_target = RADIX_TREE_PRELOAD_MIN +\n" - "+\t\tDIV_ROUND_UP(size - 1, RADIX_TREE_MAP_SIZE);\n" - "+\n" - "+\tif (WARN_ONCE(size > RADIX_TREE_PRELOAD_NR,\n" - "+\t\t\t\t\"too large preload requested\"))\n" - "+\t\treturn -ENOMEM;\n" - " \n" - " \tpreempt_disable();\n" - " \trtp = &__get_cpu_var(radix_tree_preloads);\n" - "-\twhile (rtp->nr < ARRAY_SIZE(rtp->nodes)) {\n" - "+\twhile (rtp->nr < preload_target) {\n" - " \t\tpreempt_enable();\n" - " \t\tnode = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask);\n" - " \t\tif (node == NULL)\n" - " \t\t\tgoto out;\n" - " \t\tpreempt_disable();\n" - " \t\trtp = &__get_cpu_var(radix_tree_preloads);\n" - "-\t\tif (rtp->nr < ARRAY_SIZE(rtp->nodes))\n" - "+\t\tif (rtp->nr < preload_target)\n" - " \t\t\trtp->nodes[rtp->nr++] = node;\n" - " \t\telse\n" - " \t\t\tkmem_cache_free(radix_tree_node_cachep, node);\n" - "@@ -308,7 +354,7 @@ int radix_tree_preload(gfp_t gfp_mask)\n" - " {\n" - " \t/* Warn on non-sensical use... */\n" - " \tWARN_ON_ONCE(!(gfp_mask & __GFP_WAIT));\n" - "-\treturn __radix_tree_preload(gfp_mask);\n" - "+\treturn __radix_tree_preload_contig(1, gfp_mask);\n" - " }\n" - " EXPORT_SYMBOL(radix_tree_preload);\n" - " \n" - "@@ -320,13 +366,22 @@ EXPORT_SYMBOL(radix_tree_preload);\n" - " int radix_tree_maybe_preload(gfp_t gfp_mask)\n" - " {\n" - " \tif (gfp_mask & __GFP_WAIT)\n" - "-\t\treturn __radix_tree_preload(gfp_mask);\n" - "+\t\treturn __radix_tree_preload_contig(1, gfp_mask);\n" - " \t/* Preloading doesn't help anything with this gfp mask, skip it */\n" - " \tpreempt_disable();\n" - " \treturn 0;\n" - " }\n" - " EXPORT_SYMBOL(radix_tree_maybe_preload);\n" - " \n" - "+int radix_tree_maybe_preload_contig(unsigned size, gfp_t gfp_mask)\n" - "+{\n" - "+\tif (gfp_mask & __GFP_WAIT)\n" - "+\t\treturn __radix_tree_preload_contig(size, gfp_mask);\n" - "+\t/* Preloading doesn't help anything with this gfp mask, skip it */\n" - "+\tpreempt_disable();\n" - "+\treturn 0;\n" - "+}\n" - "+\n" - " /*\n" - " *\tReturn the maximum key which can be store into a\n" - " *\tradix tree with height HEIGHT.\n" - "@@ -1483,6 +1538,22 @@ static int radix_tree_callback(struct notifier_block *nfb,\n" - " \n" - " void __init radix_tree_init(void)\n" - " {\n" - "+\t/*\n" - "+\t * Restrictions on RADIX_TREE_PRELOAD_NR simplify RADIX_TREE_PRELOAD_MAX\n" - "+\t * calculation, it's already complex enough:\n" - "+\t * - it must be multiplier of RADIX_TREE_MAP_SIZE, otherwise we will\n" - "+\t * have to round it up to next RADIX_TREE_MAP_SIZE multiplier and we\n" - "+\t * don't win anything;\n" - "+\t * - must be less then number of items 2-level tree can contain.\n" - "+\t * It's easier to calculate number of internal nodes required\n" - "+\t * this way.\n" - "+\t */\n" - "+\tif (RADIX_TREE_PRELOAD_NR != 1) {\n" - "+\t\tBUILD_BUG_ON(RADIX_TREE_PRELOAD_NR % RADIX_TREE_MAP_SIZE != 0);\n" - "+\t\tBUILD_BUG_ON(RADIX_TREE_PRELOAD_NR >\n" - "+\t\t\t\t1UL << (2 * RADIX_TREE_MAP_SHIFT));\n" - "+\t}\n" - "+\n" - " \tradix_tree_node_cachep = kmem_cache_create(\"radix_tree_node\",\n" - " \t\t\tsizeof(struct radix_tree_node), 0,\n" - " \t\t\tSLAB_PANIC | SLAB_RECLAIM_ACCOUNT,\n" - "-- \n" - "1.8.3.2\n" - "\n" - "-- \n" - " Kirill A. Shutemov\n" - "\n" - "--\n" - "To unsubscribe, send a message with 'unsubscribe linux-mm' in\n" - "the body to majordomo@kvack.org. For more info on Linux MM,\n" - "see: http://www.linux-mm.org/ .\n" - "Don't email: <a href=mailto:\"dont@kvack.org\"> email@kvack.org </a>" + Patch is below. Please review. -30cdf65e6353dcdb364605ffb00c7519cfd8fe88f56411696d16b8663ab5d1d7 +46868521a46ad2ff6ba0bcc78cc9be18a7fcf656b26aab2e4293576b68a76911
diff --git a/a/1.txt b/N2/1.txt index 60b0c29..f721be7 100644 --- a/a/1.txt +++ b/N2/1.txt @@ -268,9 +268,3 @@ index 7811ed3..980e4c4 100644 -- Kirill A. Shutemov - --- -To unsubscribe, send a message with 'unsubscribe linux-mm' in -the body to majordomo@kvack.org. For more info on Linux MM, -see: http://www.linux-mm.org/ . -Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a> diff --git a/a/content_digest b/N2/content_digest index 888f7a3..3b98c75 100644 --- a/a/content_digest +++ b/N2/content_digest @@ -298,12 +298,6 @@ "1.8.3.2\n" "\n" "-- \n" - " Kirill A. Shutemov\n" - "\n" - "--\n" - "To unsubscribe, send a message with 'unsubscribe linux-mm' in\n" - "the body to majordomo@kvack.org. For more info on Linux MM,\n" - "see: http://www.linux-mm.org/ .\n" - "Don't email: <a href=mailto:\"dont@kvack.org\"> email@kvack.org </a>" + Kirill A. Shutemov -30cdf65e6353dcdb364605ffb00c7519cfd8fe88f56411696d16b8663ab5d1d7 +3018ad05e2330054740af7b52ba7df82e9c31a54cc556834f0ec8ca62662cc8d
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.