thp, vmstat: implement HZP_ALLOC and HZP_ALLOC_FAILED events

hzp_alloc is incremented every time a huge zero page is successfully
	allocated. It includes allocations which where dropped due
	race with other allocation. Note, it doesn't count every map
	of the huge zero page, only its allocation.

hzp_alloc_failed is incremented if kernel fails to allocate huge zero
	page and falls back to using small pages.

Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: "H. Peter Anvin" <hpa@linux.intel.com>
Cc: Mel Gorman <mel@csn.ul.ie>
Cc: David Rientjes <rientjes@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/Documentation/vm/transhuge.txt b/Documentation/vm/transhuge.txt
index 197e93d34c96a359c1e93ef81da7acb5bde88836..60aeedd54615328c00937691685066f9348c0fe5 100644 (file)
--- a/Documentation/vm/transhuge.txt
+++ b/Documentation/vm/transhuge.txt
@@ -197,13 +197,13 @@ thp_split is incremented every time a huge page is split into base
        pages. This can happen for a variety of reasons but a common
        reason is that a huge page is old and is being reclaimed.
 
-hzp_alloc is incremented every time a huge zero page is successfully
-       allocated. It includes allocations which where dropped due
-       race with other allocation. Note, it doesn't count every map
-       of the huge zero page, only its allocation.
+thp_zero_page_alloc is incremented every time a huge zero page is
+       successfully allocated. It includes allocations which where
+       dropped due race with other allocation. Note, it doesn't count
+       every map of the huge zero page, only its allocation.
 
-hzp_alloc_failed is incremented if kernel fails to allocate huge zero
-       page and falls back to using small pages.
+thp_zero_page_alloc_failed is incremented if kernel fails to allocate
+       huge zero page and falls back to using small pages.
 
 As the system ages, allocating huge pages may be expensive as the
 system uses memory compaction to copy data around memory to free a

diff --git a/include/linux/vm_event_item.h b/include/linux/vm_event_item.h
index de74d6e0212e3dccd723d8f981372cb1a567f718..4278e6cf9c8b89c798292f4939de340d3e11e18c 100644 (file)
--- a/include/linux/vm_event_item.h
+++ b/include/linux/vm_event_item.h
@@ -63,8 +63,8 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                THP_COLLAPSE_ALLOC,
                THP_COLLAPSE_ALLOC_FAILED,
                THP_SPLIT,
-               HZP_ALLOC,
-               HZP_ALLOC_FAILED,
+               THP_ZERO_PAGE_ALLOC,
+               THP_ZERO_PAGE_ALLOC_FAILED,
 #endif
                NR_VM_EVENT_ITEMS
 };

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index fc00c064df22c074411733423af83d3b823d3afc..95747f6445d353c1d51f98c53153cccb696b9e52 100644 (file)
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -186,10 +186,10 @@ retry:
        zero_page = alloc_pages((GFP_TRANSHUGE | __GFP_ZERO) & ~__GFP_MOVABLE,
                        HPAGE_PMD_ORDER);
        if (!zero_page) {
-               count_vm_event(HZP_ALLOC_FAILED);
+               count_vm_event(THP_ZERO_PAGE_ALLOC_FAILED);
                return 0;
        }
-       count_vm_event(HZP_ALLOC);
+       count_vm_event(THP_ZERO_PAGE_ALLOC);
        preempt_disable();
        if (cmpxchg(&huge_zero_pfn, 0, page_to_pfn(zero_page))) {
                preempt_enable();

diff --git a/mm/vmstat.c b/mm/vmstat.c
index e931e1daa9aa24fd9cd3f369dc150e3b295829b3..ab7cb648c509fda811351c7d4afad72e6bdf71bd 100644 (file)
--- a/mm/vmstat.c
+++ b/mm/vmstat.c
@@ -808,8 +808,8 @@ const char * const vmstat_text[] = {
        "thp_collapse_alloc",
        "thp_collapse_alloc_failed",
        "thp_split",
-       "hzp_alloc",
-       "hzp_alloc_failed",
+       "thp_zero_page_alloc",
+       "thp_zero_page_alloc_failed",
 #endif
 
 #endif /* CONFIG_VM_EVENTS_COUNTERS */