Examining Huge Pages or Transparent Huge Pages performance

All modern processors use page-based mechanisms to translate the user-space processes virtual addresses into physical addresses for RAM. The pages are commonly 4KB in size and the processor can hold a limited number of virtual-to-physical address mappings in the Translation Lookaside Buffers (TLB). The number TLB entries ranges from tens to hundreds of mappings. This limits a processor to a few
megabytes of memory it can address without changing the TLB entries. When a virtual-to-physical address mapping is not in the TLB the processor must do an expensive computation to generate a new virtual-to-physical address mapping.

To increase the amount of memory the processor can address without performing the expensive TLB updates many processors allow larger page sizes to be used. On x86_64 processors huge pages are 2MB, 512 times larger than regular 4KB pages. In ideal situations huge pages can decrease the overhead of the TLB updates (misses). However, huge page use can increase memory pressure, add latency for minor pages faults, and add overhead when splitting huge pages or coalescing normal sized pages into huge pages.

There are two mechanisms available for huge pages in Linux: the hugepages and Transparent Huge Pages (THP). Explicit configuration is required for the original hugepages mechanism. The newer transparent hugepage (THP) mechanism will automatically use larger pages for dynamically allocated memory in Red Hat Enterprise Linux 6.

To determine whether the newer Transparent HugePages (THP) or the older HugePages mechanism are being used, look at the output of /proc/meminfo as below:

$ cat /proc/meminfo|grep Huge
AnonHugePages:   3049472 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB

The AnonHugePages entry lists the number of pages that the newer Transparent Huge Page mechanism currently has in use. For this machine there are 309472kB, 1489 huge pages each 2048kB in size.

In this case there are zero pages in the pool of the older hugepage mechanism as shown by HugePages_Total of 0. The HugePages_Free shows how many pages are still available for allocation, which is going to be less than or equal to HugePages_Total. The number of HugePages in use can be computed as HugePages_TotalHugePagesFree. For more information about the configuration of HugePages see Tuning and Optimizing Red Hat Enterprise Linux for Oracle 9i and 10g Databases.

Determining whether page fault latency is due to huge pages use

Huge page use can reduce the number of TLB updates required to access large regions of memory and reducing the overall cost of TLB updates but increase costs and latency for other operations. When a user-space application is given a range of addresses for a memory allocation the assignment of a physical page is deferred until the first time the page is accessed. To prevent information leakage from the previous user of the page the kernel writes zeros in the entire page. For a 4096 byte page this is a relatively short operation and will only take a couple of microseconds. The x86 hugepages are 2MB in size, 512 times larger than the normal page. Thus, the operation may take hundreds of microseconds and impact the operation of latency sensitive code. Below is a simple SystemTap command line script to show which applications have huge pages zeroed out and how long those operations take. It will run until cntl-c is pressed.

stap  -e 'global huge_clear probe kernel.function("clear_huge_page").return {
  huge_clear [execname(), pid()] <<< (gettimeofday_us() - @entry(gettimeofday_us()))}'

Below is the a run of the above SystemTap clear huge page script. The script will output a list sorted from the executable name and process with the most huge page clears to the least. The @count is the number of times that process encountered a huge page clear operation. Following that information is time statistics displayed in microseconds of wall clock time. The @min and the @max are the minimum and the maximum time respectively to clear out a page. The @sum is the total wall clock time. In the example below the ld process 17050 took a total 1924 microseconds to clear out huge pages and on average those page clears took 128 microseconds.

#  stap  -e 'global huge_clear probe kernel.function("clear_huge_page").return {
  huge_clear [execname(), pid()] <<< (gettimeofday_us() - @entry(gettimeofday_us()))}'
^CChuge_clear["ld",17050] @count=15 @min=114 @max=148 @sum=1924 @avg=128
huge_clear["ld",27996] @count=13 @min=121 @max=160 @sum=1674 @avg=128
huge_clear["ld",19595] @count=11 @min=86 @max=181 @sum=1251 @avg=113
huge_clear["cc1",22840] @count=6 @min=108 @max=180 @sum=862 @avg=143
huge_clear["ld",15640] @count=5 @min=160 @max=599 @sum=1274 @avg=254
huge_clear["ld",27733] @count=4 @min=95 @max=145 @sum=443 @avg=110
huge_clear["cc1",24455] @count=4 @min=103 @max=159 @sum=535 @avg=133
huge_clear["cc1",20431] @count=3 @min=112 @max=172 @sum=408 @avg=136
huge_clear["cc1",21906] @count=3 @min=125 @max=159 @sum=431 @avg=143

The system may attempt to save memory by using the same physical page for multiple processes. When one of the processes attempts to modify the contents of the page a new copy needs to be made of the page. The Copy-On-Write (COW) operation for the huge page can be observed with a script very similar to the one watching for huge pages to be zeroed out. Below is the script to watch for Copy-On-Write for huge pages and it will output data in a similar format.

stap  -e 'global huge_cow probe kernel.function("copy_user_huge_page").return {
  huge_cow [execname(), pid()] <<< (gettimeofday_us() - @entry(gettimeofday_us()))}'

Determining whether huge page split and collapse operations are affecting performance

Because some portions of the kernel code only work with normal-sized pages the kernel may convert a huge page into a set of normal-sized pages using a split operation. One can identify if split operations are occurring with the following systemtap script:

stap -e 'probe kernel.function("split_huge_page") { printf("%s: %s(%d)n", pp(), execname(), pid());}'

Below is an example run of the script showing which processes are performing split huge page operations. In this case the same virtualized guest machine (qemu-system-x86_64) has some huge pages splits.

# stap -e 'probe kernel.function("split_huge_page") { printf("%s: %s(%d)n", pp(), execname(), pid());}'
kernel.function("split_huge_page@include/linux/huge_mm.h:103"): qemu-system-x86(9473)
kernel.function("split_huge_page@include/linux/huge_mm.h:103"): qemu-system-x86(9473)
kernel.function("split_huge_page@include/linux/huge_mm.h:103"): plugin-containe(16582)
kernel.function("split_huge_page@include/linux/huge_mm.h:103"): StreamT~ns #697(2942)

The inverse of the huge page split operation is the huge page collapse operation that converts a set of normal-sized pages into a single huge page. It is desirable to have a range of addresses need fewer TLB entries, but the conversion process is expensive because the system needs to find a candidate set of pages to group together and then copy all the memory from the possibly scattered normal-sized pages into a single huge page. The khugepaged kernel thread searches for candidates pages to collapse into a single huge page. Even if khugepaged is not successful converting normal-sized pages into huge pages it may still be taking processor time to search for candidate pages. You can see if the khugepaged kernel thread is taking a significant amount of processor time with:

top -p `pidof khugepaged`

If you want to see when the huge page collapse operations occur, the following will note each time khugepaged is able to collapse normal-sized pages into huge pages:

stap -e 'probe kernel.function("collapse_huge_page") {  printf("%-25s: %s (%d) collapse_huge_pagen", tz_ctime(gettimeofday_s()), execname(), pid())}'

The above one line script will generate output like the following:

$ stap -e 'probe kernel.function("collapse_huge_page") {  printf("%-25s: %s (%d) collapse_huge_pagen", ctime(gettimeofday_s()), execname(), pid())}'
Mon Oct 21 15:12:44 2013 : khugepaged (88) collapse_huge_page
Mon Oct 21 15:13:44 2013 : khugepaged (88) collapse_huge_page
Mon Oct 21 15:13:54 2013 : khugepaged (88) collapse_huge_page
Mon Oct 21 15:14:54 2013 : khugepaged (88) collapse_huge_page
Mon Oct 21 15:15:04 2013 : khugepaged (88) collapse_huge_page


Join the Red Hat Developer Program (it’s free) and get access to related cheat sheets, books, and product downloads.


Take advantage of your Red Hat Developers membership and download RHEL today at no cost.


    1. The THP mechanism is transparent and will allow dynamic memory allocation to be placed on huge pages. This doesn’t require any change to the application. However, THP doesn’t help with pages used to hold code or files. With a really simple test of pgbench I did see that a single THP was allocated for the postgresql. However, as mentioned in this blog post about THP there are cases where THP use doesn’t help performance. It would be a good idea to verify that postgresql performance is helped and not hurt by THP use. There are also many other things that could affect database perform:


  1. Hello William, I have some questions.
    1. In brief, what is the difference between set the Transparent Huge Page and set the Total Huge Page?
    2. When do you use Transparent Huge Page and When do you define the HugePagesTotal ?
    3. When do you need to make a mount to the partition hugetlbfs? –I know that this is only when you set a total web pages.
    4. How can I identify the total of HugePages_Total (?) * Hugepagesize (2MiB)
    5. How can I identify what would be the size for the hugetlbfs partition?
    6. How can I detect how many hugepages use a program?
    7. How can I detect if a program use hugetlbfs?


    1. Hi,

      There is a bit more descussion about the differences between the
      explicit and transparent huge page mechanisms at

      For the older explicit HugePages pool mechanism that number of pages
      needs to be specified early since memory may become fragmented and the
      machine will be unable to allocate the large pages.

      Yes, you should be able to us the Hugepagesize information in
      /dev/meminfo to compute the amount of memory for various HugePages_*
      categories. HugePages_Total is the total number of pages in the pool
      both used and free pages.

      As far as whether a process is using huge pages you should be able to
      get that information from the “numastat -p “. There is also some
      information at https://access.redhat.com/solutions/46111


Leave a Reply