diff for duplicates of <573F17B4.70701@suse.cz> diff --git a/a/1.txt b/N1/1.txt index f5f2c24..6abb30f 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -36,3 +36,196 @@ OK I took the core idea and arrived at the following. I think it could work and the amount of further per-site modifications to GFP_TRANSHUGE* is reduced, but if anyone think it's overkill to have two GFP_TRANSHUGE*, I will just return to the original patch. + +>From 48ddb10e96fd9741a9eb3be9672c13589db7239a Mon Sep 17 00:00:00 2001 +From: Vlastimil Babka <vbabka@suse.cz> +Date: Wed, 4 May 2016 13:40:03 +0200 +Subject: [PATCH] mm, thp: remove __GFP_NORETRY from khugepaged and madvised + allocations + +After the previous patch, we can distinguish costly allocations that should be +really lightweight, such as THP page faults, with __GFP_NORETRY. This means we +don't need to recognize khugepaged allocations via PF_KTHREAD anymore. We can +also change THP page faults in areas where madvise(MADV_HUGEPAGE) was used to +try as hard as khugepaged, as the process has indicated that it benefits from +THP's and is willing to pay some initial latency costs. + +We can also make the flags handling less cryptic by distinguishing +GFP_TRANSHUGE_LIGHT (no reclaim at all, default mode in page fault) from +GFP_TRANSHUGE (only direct reclaim, khugepaged default). Adding __GFP_NORETRY +or __GFP_KSWAPD_RECLAIM is done where needed. + +The patch effectively changes the current GFP_TRANSHUGE users as follows: + +* get_huge_zero_page() - the zero page lifetime should be relatively long and + it's shared by multiple users, so it's worth spending some effort on it. + We use GFP_TRANSHUGE, and __GFP_NORETRY is not added. This also restores + direct reclaim to this allocation, which was unintentionally removed by + commit e4a49efe4e7e ("mm: thp: set THP defrag by default to madvise and add + a stall-free defrag option") + +* alloc_hugepage_khugepaged_gfpmask() - this is khugepaged, so latency is not + an issue. So if khugepaged "defrag" is enabled (the default), do reclaim + via GFP_TRANSHUGE without __GFP_NORETRY. We can remove the PF_KTHREAD check + from page alloc. + As a side-effect, khugepaged will now no longer check if the initial + compaction was deferred or contended. This is OK, as khugepaged sleep times + between collapsion attemps are long enough to prevent noticeable disruption, + so we should allow it to spend some effort. + +* migrate_misplaced_transhuge_page() - already was masking out __GFP_RECLAIM, + so just convert to GFP_TRANSHUGE_LIGHT which is equivalent. + +* alloc_hugepage_direct_gfpmask() - vma's with VM_HUGEPAGE (via madvise) are + now allocating without __GFP_NORETRY. Other vma's keep using __GFP_NORETRY + if direct reclaim/compaction is at all allowed (by default it's allowed only + for madvised vma's). The rest is conversion to GFP_TRANSHUGE(_LIGHT). + +Signed-off-by: Vlastimil Babka <vbabka@suse.cz> +--- + include/linux/gfp.h | 14 ++++++++------ + include/trace/events/mmflags.h | 1 + + mm/huge_memory.c | 27 +++++++++++++++------------ + mm/migrate.c | 2 +- + mm/page_alloc.c | 6 ++---- + tools/perf/builtin-kmem.c | 1 + + 6 files changed, 28 insertions(+), 23 deletions(-) + +diff --git a/include/linux/gfp.h b/include/linux/gfp.h +index 570383a41853..1dfca27df492 100644 +--- a/include/linux/gfp.h ++++ b/include/linux/gfp.h +@@ -238,9 +238,11 @@ struct vm_area_struct; + * are expected to be movable via page reclaim or page migration. Typically, + * pages on the LRU would also be allocated with GFP_HIGHUSER_MOVABLE. + * +- * GFP_TRANSHUGE is used for THP allocations. They are compound allocations +- * that will fail quickly if memory is not available and will not wake +- * kswapd on failure. ++ * GFP_TRANSHUGE and GFP_TRANSHUGE_LIGHT are used for THP allocations. They are ++ * compound allocations that will generally fail quickly if memory is not ++ * available and will not wake kswapd/kcompactd on failure. The _LIGHT ++ * version does not attempt reclaim/compaction at all and is by default used ++ * in page fault path, while the non-light is used by khugepaged. + */ + #define GFP_ATOMIC (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM) + #define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS) +@@ -255,9 +257,9 @@ struct vm_area_struct; + #define GFP_DMA32 __GFP_DMA32 + #define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM) + #define GFP_HIGHUSER_MOVABLE (GFP_HIGHUSER | __GFP_MOVABLE) +-#define GFP_TRANSHUGE ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \ +- __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN) & \ +- ~__GFP_RECLAIM) ++#define GFP_TRANSHUGE_LIGHT ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \ ++ __GFP_NOMEMALLOC| __GFP_NOWARN) & ~__GFP_RECLAIM) ++#define GFP_TRANSHUGE (GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM) + + /* Convert GFP flags to their corresponding migrate type */ + #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) +diff --git a/include/trace/events/mmflags.h b/include/trace/events/mmflags.h +index 43cedbf0c759..5a81ab48a2fb 100644 +--- a/include/trace/events/mmflags.h ++++ b/include/trace/events/mmflags.h +@@ -11,6 +11,7 @@ + + #define __def_gfpflag_names \ + {(unsigned long)GFP_TRANSHUGE, "GFP_TRANSHUGE"}, \ ++ {(unsigned long)GFP_TRANSHUGE_LIGHT, "GFP_TRANSHUGE_LIGHT"}, \ + {(unsigned long)GFP_HIGHUSER_MOVABLE, "GFP_HIGHUSER_MOVABLE"},\ + {(unsigned long)GFP_HIGHUSER, "GFP_HIGHUSER"}, \ + {(unsigned long)GFP_USER, "GFP_USER"}, \ +diff --git a/mm/huge_memory.c b/mm/huge_memory.c +index 87f09dc986ab..aa87db8c7f8f 100644 +--- a/mm/huge_memory.c ++++ b/mm/huge_memory.c +@@ -882,29 +882,32 @@ static int __do_huge_pmd_anonymous_page(struct mm_struct *mm, + } + + /* +- * If THP is set to always then directly reclaim/compact as necessary +- * If set to defer then do no reclaim and defer to khugepaged ++ * If THP defrag is set to always then directly reclaim/compact as necessary ++ * If set to defer then do only background reclaim/compact and defer to khugepaged + * If set to madvise and the VMA is flagged then directly reclaim/compact ++ * When direct reclaim/compact is allowed, don't retry except for flagged VMA's + */ + static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma) + { +- gfp_t reclaim_flags = 0; ++ bool vma_madvised = !!(vma->vm_flags & VM_HUGEPAGE); + +- if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags) && +- (vma->vm_flags & VM_HUGEPAGE)) +- reclaim_flags = __GFP_DIRECT_RECLAIM; +- else if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags)) +- reclaim_flags = __GFP_KSWAPD_RECLAIM; +- else if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags)) +- reclaim_flags = __GFP_DIRECT_RECLAIM; ++ if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, ++ &transparent_hugepage_flags) && vma_madvised) ++ return GFP_TRANSHUGE; ++ else if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, ++ &transparent_hugepage_flags)) ++ return GFP_TRANSHUGE_LIGHT | __GFP_KSWAPD_RECLAIM; ++ else if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, ++ &transparent_hugepage_flags)) ++ return GFP_TRANSHUGE | (vma_madvised ? 0 : __GFP_NORETRY); + +- return GFP_TRANSHUGE | reclaim_flags; ++ return GFP_TRANSHUGE_LIGHT; + } + + /* Defrag for khugepaged will enter direct reclaim/compaction if necessary */ + static inline gfp_t alloc_hugepage_khugepaged_gfpmask(void) + { +- return GFP_TRANSHUGE | (khugepaged_defrag() ? __GFP_DIRECT_RECLAIM : 0); ++ return khugepaged_defrag() ? GFP_TRANSHUGE : GFP_TRANSHUGE_LIGHT; + } + + /* Caller must hold page table lock. */ +diff --git a/mm/migrate.c b/mm/migrate.c +index 53ab6398e7a2..bc82c56fa3af 100644 +--- a/mm/migrate.c ++++ b/mm/migrate.c +@@ -1771,7 +1771,7 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm, + goto out_dropref; + + new_page = alloc_pages_node(node, +- (GFP_TRANSHUGE | __GFP_THISNODE) & ~__GFP_RECLAIM, ++ (GFP_TRANSHUGE_LIGHT | __GFP_THISNODE), + HPAGE_PMD_ORDER); + if (!new_page) + goto out_fail; +diff --git a/mm/page_alloc.c b/mm/page_alloc.c +index 0cee863397e4..4a34187827ca 100644 +--- a/mm/page_alloc.c ++++ b/mm/page_alloc.c +@@ -3619,11 +3619,9 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, + /* + * Looks like reclaim/compaction is worth trying, but + * sync compaction could be very expensive, so keep +- * using async compaction, unless it's khugepaged +- * trying to collapse. ++ * using async compaction. + */ +- if (!(current->flags & PF_KTHREAD)) +- migration_mode = MIGRATE_ASYNC; ++ migration_mode = MIGRATE_ASYNC; + } + } + +diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c +index 5da5a9511cef..7fde754b344d 100644 +--- a/tools/perf/builtin-kmem.c ++++ b/tools/perf/builtin-kmem.c +@@ -608,6 +608,7 @@ static const struct { + const char *compact; + } gfp_compact_table[] = { + { "GFP_TRANSHUGE", "THP" }, ++ { "GFP_TRANSHUGE_LIGHT", "THL" }, + { "GFP_HIGHUSER_MOVABLE", "HUM" }, + { "GFP_HIGHUSER", "HU" }, + { "GFP_USER", "U" }, +-- +2.8.2 diff --git a/a/content_digest b/N1/content_digest index b07bb31..e38aa42 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -58,6 +58,199 @@ "OK I took the core idea and arrived at the following. I think it could\n" "work and the amount of further per-site modifications to GFP_TRANSHUGE*\n" "is reduced, but if anyone think it's overkill to have two\n" - GFP_TRANSHUGE*, I will just return to the original patch. + "GFP_TRANSHUGE*, I will just return to the original patch.\n" + "\n" + ">From 48ddb10e96fd9741a9eb3be9672c13589db7239a Mon Sep 17 00:00:00 2001\n" + "From: Vlastimil Babka <vbabka@suse.cz>\n" + "Date: Wed, 4 May 2016 13:40:03 +0200\n" + "Subject: [PATCH] mm, thp: remove __GFP_NORETRY from khugepaged and madvised\n" + " allocations\n" + "\n" + "After the previous patch, we can distinguish costly allocations that should be\n" + "really lightweight, such as THP page faults, with __GFP_NORETRY. This means we\n" + "don't need to recognize khugepaged allocations via PF_KTHREAD anymore. We can\n" + "also change THP page faults in areas where madvise(MADV_HUGEPAGE) was used to\n" + "try as hard as khugepaged, as the process has indicated that it benefits from\n" + "THP's and is willing to pay some initial latency costs.\n" + "\n" + "We can also make the flags handling less cryptic by distinguishing\n" + "GFP_TRANSHUGE_LIGHT (no reclaim at all, default mode in page fault) from\n" + "GFP_TRANSHUGE (only direct reclaim, khugepaged default). Adding __GFP_NORETRY\n" + "or __GFP_KSWAPD_RECLAIM is done where needed.\n" + "\n" + "The patch effectively changes the current GFP_TRANSHUGE users as follows:\n" + "\n" + "* get_huge_zero_page() - the zero page lifetime should be relatively long and\n" + " it's shared by multiple users, so it's worth spending some effort on it.\n" + " We use GFP_TRANSHUGE, and __GFP_NORETRY is not added. This also restores\n" + " direct reclaim to this allocation, which was unintentionally removed by\n" + " commit e4a49efe4e7e (\"mm: thp: set THP defrag by default to madvise and add\n" + " a stall-free defrag option\")\n" + "\n" + "* alloc_hugepage_khugepaged_gfpmask() - this is khugepaged, so latency is not\n" + " an issue. So if khugepaged \"defrag\" is enabled (the default), do reclaim\n" + " via GFP_TRANSHUGE without __GFP_NORETRY. We can remove the PF_KTHREAD check\n" + " from page alloc.\n" + " As a side-effect, khugepaged will now no longer check if the initial\n" + " compaction was deferred or contended. This is OK, as khugepaged sleep times\n" + " between collapsion attemps are long enough to prevent noticeable disruption,\n" + " so we should allow it to spend some effort.\n" + "\n" + "* migrate_misplaced_transhuge_page() - already was masking out __GFP_RECLAIM,\n" + " so just convert to GFP_TRANSHUGE_LIGHT which is equivalent.\n" + "\n" + "* alloc_hugepage_direct_gfpmask() - vma's with VM_HUGEPAGE (via madvise) are\n" + " now allocating without __GFP_NORETRY. Other vma's keep using __GFP_NORETRY\n" + " if direct reclaim/compaction is at all allowed (by default it's allowed only\n" + " for madvised vma's). The rest is conversion to GFP_TRANSHUGE(_LIGHT).\n" + "\n" + "Signed-off-by: Vlastimil Babka <vbabka@suse.cz>\n" + "---\n" + " include/linux/gfp.h | 14 ++++++++------\n" + " include/trace/events/mmflags.h | 1 +\n" + " mm/huge_memory.c | 27 +++++++++++++++------------\n" + " mm/migrate.c | 2 +-\n" + " mm/page_alloc.c | 6 ++----\n" + " tools/perf/builtin-kmem.c | 1 +\n" + " 6 files changed, 28 insertions(+), 23 deletions(-)\n" + "\n" + "diff --git a/include/linux/gfp.h b/include/linux/gfp.h\n" + "index 570383a41853..1dfca27df492 100644\n" + "--- a/include/linux/gfp.h\n" + "+++ b/include/linux/gfp.h\n" + "@@ -238,9 +238,11 @@ struct vm_area_struct;\n" + " * are expected to be movable via page reclaim or page migration. Typically,\n" + " * pages on the LRU would also be allocated with GFP_HIGHUSER_MOVABLE.\n" + " *\n" + "- * GFP_TRANSHUGE is used for THP allocations. They are compound allocations\n" + "- * that will fail quickly if memory is not available and will not wake\n" + "- * kswapd on failure.\n" + "+ * GFP_TRANSHUGE and GFP_TRANSHUGE_LIGHT are used for THP allocations. They are\n" + "+ * compound allocations that will generally fail quickly if memory is not\n" + "+ * available and will not wake kswapd/kcompactd on failure. The _LIGHT\n" + "+ * version does not attempt reclaim/compaction at all and is by default used\n" + "+ * in page fault path, while the non-light is used by khugepaged.\n" + " */\n" + " #define GFP_ATOMIC\t(__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)\n" + " #define GFP_KERNEL\t(__GFP_RECLAIM | __GFP_IO | __GFP_FS)\n" + "@@ -255,9 +257,9 @@ struct vm_area_struct;\n" + " #define GFP_DMA32\t__GFP_DMA32\n" + " #define GFP_HIGHUSER\t(GFP_USER | __GFP_HIGHMEM)\n" + " #define GFP_HIGHUSER_MOVABLE\t(GFP_HIGHUSER | __GFP_MOVABLE)\n" + "-#define GFP_TRANSHUGE\t((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \\\n" + "-\t\t\t __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN) & \\\n" + "-\t\t\t ~__GFP_RECLAIM)\n" + "+#define GFP_TRANSHUGE_LIGHT\t((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \\\n" + "+\t\t\t __GFP_NOMEMALLOC| __GFP_NOWARN) & ~__GFP_RECLAIM)\n" + "+#define GFP_TRANSHUGE\t(GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM)\n" + " \n" + " /* Convert GFP flags to their corresponding migrate type */\n" + " #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)\n" + "diff --git a/include/trace/events/mmflags.h b/include/trace/events/mmflags.h\n" + "index 43cedbf0c759..5a81ab48a2fb 100644\n" + "--- a/include/trace/events/mmflags.h\n" + "+++ b/include/trace/events/mmflags.h\n" + "@@ -11,6 +11,7 @@\n" + " \n" + " #define __def_gfpflag_names\t\t\t\t\t\t\\\n" + " \t{(unsigned long)GFP_TRANSHUGE,\t\t\"GFP_TRANSHUGE\"},\t\\\n" + "+\t{(unsigned long)GFP_TRANSHUGE_LIGHT,\t\"GFP_TRANSHUGE_LIGHT\"}, \\\n" + " \t{(unsigned long)GFP_HIGHUSER_MOVABLE,\t\"GFP_HIGHUSER_MOVABLE\"},\\\n" + " \t{(unsigned long)GFP_HIGHUSER,\t\t\"GFP_HIGHUSER\"},\t\\\n" + " \t{(unsigned long)GFP_USER,\t\t\"GFP_USER\"},\t\t\\\n" + "diff --git a/mm/huge_memory.c b/mm/huge_memory.c\n" + "index 87f09dc986ab..aa87db8c7f8f 100644\n" + "--- a/mm/huge_memory.c\n" + "+++ b/mm/huge_memory.c\n" + "@@ -882,29 +882,32 @@ static int __do_huge_pmd_anonymous_page(struct mm_struct *mm,\n" + " }\n" + " \n" + " /*\n" + "- * If THP is set to always then directly reclaim/compact as necessary\n" + "- * If set to defer then do no reclaim and defer to khugepaged\n" + "+ * If THP defrag is set to always then directly reclaim/compact as necessary\n" + "+ * If set to defer then do only background reclaim/compact and defer to khugepaged\n" + " * If set to madvise and the VMA is flagged then directly reclaim/compact\n" + "+ * When direct reclaim/compact is allowed, don't retry except for flagged VMA's\n" + " */\n" + " static inline gfp_t alloc_hugepage_direct_gfpmask(struct vm_area_struct *vma)\n" + " {\n" + "-\tgfp_t reclaim_flags = 0;\n" + "+\tbool vma_madvised = !!(vma->vm_flags & VM_HUGEPAGE);\n" + " \n" + "-\tif (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG, &transparent_hugepage_flags) &&\n" + "-\t (vma->vm_flags & VM_HUGEPAGE))\n" + "-\t\treclaim_flags = __GFP_DIRECT_RECLAIM;\n" + "-\telse if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG, &transparent_hugepage_flags))\n" + "-\t\treclaim_flags = __GFP_KSWAPD_RECLAIM;\n" + "-\telse if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG, &transparent_hugepage_flags))\n" + "-\t\treclaim_flags = __GFP_DIRECT_RECLAIM;\n" + "+\tif (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG,\n" + "+\t\t\t\t&transparent_hugepage_flags) && vma_madvised)\n" + "+\t\treturn GFP_TRANSHUGE;\n" + "+\telse if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG,\n" + "+\t\t\t\t\t\t&transparent_hugepage_flags))\n" + "+\t\treturn GFP_TRANSHUGE_LIGHT | __GFP_KSWAPD_RECLAIM;\n" + "+\telse if (test_bit(TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG,\n" + "+\t\t\t\t\t\t&transparent_hugepage_flags))\n" + "+\t\treturn GFP_TRANSHUGE | (vma_madvised ? 0 : __GFP_NORETRY);\n" + " \n" + "-\treturn GFP_TRANSHUGE | reclaim_flags;\n" + "+\treturn GFP_TRANSHUGE_LIGHT;\n" + " }\n" + " \n" + " /* Defrag for khugepaged will enter direct reclaim/compaction if necessary */\n" + " static inline gfp_t alloc_hugepage_khugepaged_gfpmask(void)\n" + " {\n" + "-\treturn GFP_TRANSHUGE | (khugepaged_defrag() ? __GFP_DIRECT_RECLAIM : 0);\n" + "+\treturn khugepaged_defrag() ? GFP_TRANSHUGE : GFP_TRANSHUGE_LIGHT;\n" + " }\n" + " \n" + " /* Caller must hold page table lock. */\n" + "diff --git a/mm/migrate.c b/mm/migrate.c\n" + "index 53ab6398e7a2..bc82c56fa3af 100644\n" + "--- a/mm/migrate.c\n" + "+++ b/mm/migrate.c\n" + "@@ -1771,7 +1771,7 @@ int migrate_misplaced_transhuge_page(struct mm_struct *mm,\n" + " \t\tgoto out_dropref;\n" + " \n" + " \tnew_page = alloc_pages_node(node,\n" + "-\t\t(GFP_TRANSHUGE | __GFP_THISNODE) & ~__GFP_RECLAIM,\n" + "+\t\t(GFP_TRANSHUGE_LIGHT | __GFP_THISNODE),\n" + " \t\tHPAGE_PMD_ORDER);\n" + " \tif (!new_page)\n" + " \t\tgoto out_fail;\n" + "diff --git a/mm/page_alloc.c b/mm/page_alloc.c\n" + "index 0cee863397e4..4a34187827ca 100644\n" + "--- a/mm/page_alloc.c\n" + "+++ b/mm/page_alloc.c\n" + "@@ -3619,11 +3619,9 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,\n" + " \t\t\t/*\n" + " \t\t\t * Looks like reclaim/compaction is worth trying, but\n" + " \t\t\t * sync compaction could be very expensive, so keep\n" + "-\t\t\t * using async compaction, unless it's khugepaged\n" + "-\t\t\t * trying to collapse.\n" + "+\t\t\t * using async compaction.\n" + " \t\t\t */\n" + "-\t\t\tif (!(current->flags & PF_KTHREAD))\n" + "-\t\t\t\tmigration_mode = MIGRATE_ASYNC;\n" + "+\t\t\tmigration_mode = MIGRATE_ASYNC;\n" + " \t\t}\n" + " \t}\n" + " \n" + "diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c\n" + "index 5da5a9511cef..7fde754b344d 100644\n" + "--- a/tools/perf/builtin-kmem.c\n" + "+++ b/tools/perf/builtin-kmem.c\n" + "@@ -608,6 +608,7 @@ static const struct {\n" + " \tconst char *compact;\n" + " } gfp_compact_table[] = {\n" + " \t{ \"GFP_TRANSHUGE\",\t\t\"THP\" },\n" + "+\t{ \"GFP_TRANSHUGE_LIGHT\",\t\"THL\" },\n" + " \t{ \"GFP_HIGHUSER_MOVABLE\",\t\"HUM\" },\n" + " \t{ \"GFP_HIGHUSER\",\t\t\"HU\" },\n" + " \t{ \"GFP_USER\",\t\t\t\"U\" },\n" + "-- \n" + 2.8.2 -4a15661e9e88d54fa1e6388aa32ff213f87f7148afc776146df12a04342c650d +5ab116ec61ac2fa1ddb5b7a2e02ce0bbf44f43942bfe46de49adceaec22d2b16
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.