Lines Matching +full:memory +full:- +full:mapped
8 Performance critical computing applications dealing with large memory
11 using huge pages for the backing of virtual memory with huge pages
15 Currently THP only works for anonymous memory mappings and tmpfs/shmem.
26 requiring larger clear-page copy-page in page faults which is a
30 only matters the first time the memory is accessed for the lifetime of
31 a memory mapping. The second long lasting and much more important
32 factor will affect all subsequent accesses to the memory for the whole
41 memory in turn reducing the number of TLB misses. With
42 virtualization and nested pagetables the TLB can be mapped of
48 Modern kernels support "multi-size THP" (mTHP), which introduces the
49 ability to allocate memory in blocks that are bigger than a base page
50 but smaller than traditional PMD-size (as described above), in
51 increments of a power-of-2 number of pages. mTHP can back anonymous
52 memory (for example 16K, 32K, 64K, etc). These THPs continue to be
53 PTE-mapped, but in many cases can still provide similar benefits to
56 prominent because the size of each page isn't as huge as the PMD-sized
57 variant and there is less memory to clear in each page fault. Some
64 memory ranges inside task's address space. Unless THP is completely
65 disabled, there is ``khugepaged`` daemon that scans memory and
66 collapses sequences of basic pages into PMD-sized huge pages.
71 Transparent Hugepage Support maximizes the usefulness of free memory
73 unused memory to be used as cache or other movable (or even unmovable
85 deals with large amounts of memory.
88 may end up allocating more memory resources. An application may mmap a
91 possible to disable hugepages system-wide and to only have them inside
95 to eliminate any risk of wasting any precious byte of memory and to
99 risk to lose memory by using hugepages, should use
108 -------------------
110 Transparent Hugepage Support for anonymous memory can be disabled
112 regions (to avoid the risk of consuming more memory resources) or enabled
113 system wide. This can be achieved per-supported-THP-size with one of::
115 echo always >/sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/enabled
116 echo madvise >/sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/enabled
117 echo never >/sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/enabled
125 PMD-sized huge pages unconditionally.
129 echo always >/sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled
132 will inherit the top-level "enabled" value::
134 echo inherit >/sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/enabled
138 echo inherit >/sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled
140 The top-level setting (for use with "inherit") can be set by issuing
147 By default, PMD-sized hugepages have enabled="inherit" and all other
154 regions or to never try to defrag memory and simply fallback to regular
156 time to defrag memory, we would expect to gain even more by the fact we
172 memory in an effort to allocate a THP immediately. This may be
178 to reclaim pages and wake kcompactd to compact memory so that
186 pages and wake kcompactd to compact memory so that THP is
195 should be self-explanatory. Note that ``madvise(...,
199 By default kernel tries to use huge, PMD-mappable zero page on read
206 Some userspace (such as a test program, or an optimized memory
208 PMD-mappable transparent hugepage::
213 and will therefore be split under memory presure if they are considered
214 "underused". A THP is underused if the number of zero-filled pages in
222 khugepaged will be automatically started when PMD-sized THP is enabled
223 (either of the per-size anon control or the top-level control are set
225 PMD-sized THP is disabled (when both the per-size anon control and the
226 top-level control are "never")
229 -------------------
233 PMD-sized THP and no attempt is made to collapse to other THP
265 the type of memory and the failures that occur. As such, this value should
276 not already mapped) can be allocated when collapsing a group
281 A higher value leads to use additional memory for programs.
292 memory. A lower value can prevent THPs from being
294 THPs, and lower memory access performance.
302 A higher value may increase memory footprint for some workloads.
307 You can change the sysfs boot time default for the top-level "enabled"
313 passing ``thp_anon=<size>[KMG],<size>[KMG]:<state>;<size>[KMG]-<size>[KMG]:<state>``,
322 thp_anon=16K-64K:always;128K,512K:inherit;256K:madvise;1M-2M:never
369 it also supports smaller sizes just like anonymous memory, often referred
370 to as "multi-size THP" (mTHP). Huge pages of any size are commonly
379 ------------
405 ``mount -o remount,huge= /mountpoint`` works fine after mount: remounting
417 Force the huge option on for all - very useful for testing;
420 ----------------------
427 '/sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/shmem_enabled'
433 per-size knob is set to 'inherit'.
442 Inherit the top-level "shmem_enabled" value. By default, PMD-sized hugepages
461 transparent_hugepage/hugepages-<size>kB/enabled values and tmpfs mount
469 The number of PMD-sized anonymous transparent huge pages currently used by the
471 To identify what applications are using PMD-sized anonymous transparent huge
474 PMD-sized THP for historical reasons and should have been called
477 The number of file transparent huge pages mapped to userspace is available
529 is incremented every time a file or shmem huge page is mapped into
536 This action implies splitting all PMD the page mapped with.
545 splitting it would free up some memory. Pages on split queue are
546 going to be split under memory pressure.
578 In /sys/kernel/mm/transparent_hugepage/hugepages-<size>kB/stats, There are
602 is incremented every time a huge page is swapped in from a non-zswap
616 is incremented every time a huge page is swapped out to a non-zswap
649 it would free up some memory. Pages on split queue are going to
650 be split under memory pressure, if splitting is possible.
654 might be currently entirely mapped or have partially unmapped/unused
658 the number of anonymous THP which are likely partially mapped, possibly
659 wasting memory, and have been queued for deferred memory reclamation.
661 an anonymous THP as "partially mapped" and count it here, even though it
662 is not actually partially mapped anymore.
665 system uses memory compaction to copy data around memory to free a
671 memory compaction so that a huge page is free for use.
674 is incremented if the system compacted memory and
678 is incremented if the system tries to compact memory
690 memory region, the mmap region has to be hugepage naturally