253 lines
11 KiB
Plaintext
253 lines
11 KiB
Plaintext
Page migration
|
|
--------------
|
|
|
|
Page migration allows the moving of the physical location of pages between
|
|
nodes in a numa system while the process is running. This means that the
|
|
virtual addresses that the process sees do not change. However, the
|
|
system rearranges the physical location of those pages.
|
|
|
|
The main intend of page migration is to reduce the latency of memory access
|
|
by moving pages near to the processor where the process accessing that memory
|
|
is running.
|
|
|
|
Page migration allows a process to manually relocate the node on which its
|
|
pages are located through the MF_MOVE and MF_MOVE_ALL options while setting
|
|
a new memory policy via mbind(). The pages of process can also be relocated
|
|
from another process using the sys_migrate_pages() function call. The
|
|
migrate_pages function call takes two sets of nodes and moves pages of a
|
|
process that are located on the from nodes to the destination nodes.
|
|
Page migration functions are provided by the numactl package by Andi Kleen
|
|
(a version later than 0.9.3 is required. Get it from
|
|
ftp://oss.sgi.com/www/projects/libnuma/download/). numactl provides libnuma
|
|
which provides an interface similar to other numa functionality for page
|
|
migration. cat /proc/<pid>/numa_maps allows an easy review of where the
|
|
pages of a process are located. See also the numa_maps documentation in the
|
|
proc(5) man page.
|
|
|
|
Manual migration is useful if for example the scheduler has relocated
|
|
a process to a processor on a distant node. A batch scheduler or an
|
|
administrator may detect the situation and move the pages of the process
|
|
nearer to the new processor. The kernel itself does only provide
|
|
manual page migration support. Automatic page migration may be implemented
|
|
through user space processes that move pages. A special function call
|
|
"move_pages" allows the moving of individual pages within a process.
|
|
A NUMA profiler may f.e. obtain a log showing frequent off node
|
|
accesses and may use the result to move pages to more advantageous
|
|
locations.
|
|
|
|
Larger installations usually partition the system using cpusets into
|
|
sections of nodes. Paul Jackson has equipped cpusets with the ability to
|
|
move pages when a task is moved to another cpuset (See
|
|
Documentation/cgroup-v1/cpusets.txt).
|
|
Cpusets allows the automation of process locality. If a task is moved to
|
|
a new cpuset then also all its pages are moved with it so that the
|
|
performance of the process does not sink dramatically. Also the pages
|
|
of processes in a cpuset are moved if the allowed memory nodes of a
|
|
cpuset are changed.
|
|
|
|
Page migration allows the preservation of the relative location of pages
|
|
within a group of nodes for all migration techniques which will preserve a
|
|
particular memory allocation pattern generated even after migrating a
|
|
process. This is necessary in order to preserve the memory latencies.
|
|
Processes will run with similar performance after migration.
|
|
|
|
Page migration occurs in several steps. First a high level
|
|
description for those trying to use migrate_pages() from the kernel
|
|
(for userspace usage see the Andi Kleen's numactl package mentioned above)
|
|
and then a low level description of how the low level details work.
|
|
|
|
A. In kernel use of migrate_pages()
|
|
-----------------------------------
|
|
|
|
1. Remove pages from the LRU.
|
|
|
|
Lists of pages to be migrated are generated by scanning over
|
|
pages and moving them into lists. This is done by
|
|
calling isolate_lru_page().
|
|
Calling isolate_lru_page increases the references to the page
|
|
so that it cannot vanish while the page migration occurs.
|
|
It also prevents the swapper or other scans to encounter
|
|
the page.
|
|
|
|
2. We need to have a function of type new_page_t that can be
|
|
passed to migrate_pages(). This function should figure out
|
|
how to allocate the correct new page given the old page.
|
|
|
|
3. The migrate_pages() function is called which attempts
|
|
to do the migration. It will call the function to allocate
|
|
the new page for each page that is considered for
|
|
moving.
|
|
|
|
B. How migrate_pages() works
|
|
----------------------------
|
|
|
|
migrate_pages() does several passes over its list of pages. A page is moved
|
|
if all references to a page are removable at the time. The page has
|
|
already been removed from the LRU via isolate_lru_page() and the refcount
|
|
is increased so that the page cannot be freed while page migration occurs.
|
|
|
|
Steps:
|
|
|
|
1. Lock the page to be migrated
|
|
|
|
2. Insure that writeback is complete.
|
|
|
|
3. Lock the new page that we want to move to. It is locked so that accesses to
|
|
this (not yet uptodate) page immediately lock while the move is in progress.
|
|
|
|
4. All the page table references to the page are converted to migration
|
|
entries. This decreases the mapcount of a page. If the resulting
|
|
mapcount is not zero then we do not migrate the page. All user space
|
|
processes that attempt to access the page will now wait on the page lock.
|
|
|
|
5. The radix tree lock is taken. This will cause all processes trying
|
|
to access the page via the mapping to block on the radix tree spinlock.
|
|
|
|
6. The refcount of the page is examined and we back out if references remain
|
|
otherwise we know that we are the only one referencing this page.
|
|
|
|
7. The radix tree is checked and if it does not contain the pointer to this
|
|
page then we back out because someone else modified the radix tree.
|
|
|
|
8. The new page is prepped with some settings from the old page so that
|
|
accesses to the new page will discover a page with the correct settings.
|
|
|
|
9. The radix tree is changed to point to the new page.
|
|
|
|
10. The reference count of the old page is dropped because the radix tree
|
|
reference is gone. A reference to the new page is established because
|
|
the new page is referenced to by the radix tree.
|
|
|
|
11. The radix tree lock is dropped. With that lookups in the mapping
|
|
become possible again. Processes will move from spinning on the tree_lock
|
|
to sleeping on the locked new page.
|
|
|
|
12. The page contents are copied to the new page.
|
|
|
|
13. The remaining page flags are copied to the new page.
|
|
|
|
14. The old page flags are cleared to indicate that the page does
|
|
not provide any information anymore.
|
|
|
|
15. Queued up writeback on the new page is triggered.
|
|
|
|
16. If migration entries were page then replace them with real ptes. Doing
|
|
so will enable access for user space processes not already waiting for
|
|
the page lock.
|
|
|
|
19. The page locks are dropped from the old and new page.
|
|
Processes waiting on the page lock will redo their page faults
|
|
and will reach the new page.
|
|
|
|
20. The new page is moved to the LRU and can be scanned by the swapper
|
|
etc again.
|
|
|
|
C. Non-LRU page migration
|
|
-------------------------
|
|
|
|
Although original migration aimed for reducing the latency of memory access
|
|
for NUMA, compaction who want to create high-order page is also main customer.
|
|
|
|
Current problem of the implementation is that it is designed to migrate only
|
|
*LRU* pages. However, there are potential non-lru pages which can be migrated
|
|
in drivers, for example, zsmalloc, virtio-balloon pages.
|
|
|
|
For virtio-balloon pages, some parts of migration code path have been hooked
|
|
up and added virtio-balloon specific functions to intercept migration logics.
|
|
It's too specific to a driver so other drivers who want to make their pages
|
|
movable would have to add own specific hooks in migration path.
|
|
|
|
To overclome the problem, VM supports non-LRU page migration which provides
|
|
generic functions for non-LRU movable pages without driver specific hooks
|
|
migration path.
|
|
|
|
If a driver want to make own pages movable, it should define three functions
|
|
which are function pointers of struct address_space_operations.
|
|
|
|
1. bool (*isolate_page) (struct page *page, isolate_mode_t mode);
|
|
|
|
What VM expects on isolate_page function of driver is to return *true*
|
|
if driver isolates page successfully. On returing true, VM marks the page
|
|
as PG_isolated so concurrent isolation in several CPUs skip the page
|
|
for isolation. If a driver cannot isolate the page, it should return *false*.
|
|
|
|
Once page is successfully isolated, VM uses page.lru fields so driver
|
|
shouldn't expect to preserve values in that fields.
|
|
|
|
2. int (*migratepage) (struct address_space *mapping,
|
|
struct page *newpage, struct page *oldpage, enum migrate_mode);
|
|
|
|
After isolation, VM calls migratepage of driver with isolated page.
|
|
The function of migratepage is to move content of the old page to new page
|
|
and set up fields of struct page newpage. Keep in mind that you should
|
|
indicate to the VM the oldpage is no longer movable via __ClearPageMovable()
|
|
under page_lock if you migrated the oldpage successfully and returns
|
|
MIGRATEPAGE_SUCCESS. If driver cannot migrate the page at the moment, driver
|
|
can return -EAGAIN. On -EAGAIN, VM will retry page migration in a short time
|
|
because VM interprets -EAGAIN as "temporal migration failure". On returning
|
|
any error except -EAGAIN, VM will give up the page migration without retrying
|
|
in this time.
|
|
|
|
Driver shouldn't touch page.lru field VM using in the functions.
|
|
|
|
3. void (*putback_page)(struct page *);
|
|
|
|
If migration fails on isolated page, VM should return the isolated page
|
|
to the driver so VM calls driver's putback_page with migration failed page.
|
|
In this function, driver should put the isolated page back to the own data
|
|
structure.
|
|
|
|
4. non-lru movable page flags
|
|
|
|
There are two page flags for supporting non-lru movable page.
|
|
|
|
* PG_movable
|
|
|
|
Driver should use the below function to make page movable under page_lock.
|
|
|
|
void __SetPageMovable(struct page *page, struct address_space *mapping)
|
|
|
|
It needs argument of address_space for registering migration family functions
|
|
which will be called by VM. Exactly speaking, PG_movable is not a real flag of
|
|
struct page. Rather than, VM reuses page->mapping's lower bits to represent it.
|
|
|
|
#define PAGE_MAPPING_MOVABLE 0x2
|
|
page->mapping = page->mapping | PAGE_MAPPING_MOVABLE;
|
|
|
|
so driver shouldn't access page->mapping directly. Instead, driver should
|
|
use page_mapping which mask off the low two bits of page->mapping under
|
|
page lock so it can get right struct address_space.
|
|
|
|
For testing of non-lru movable page, VM supports __PageMovable function.
|
|
However, it doesn't guarantee to identify non-lru movable page because
|
|
page->mapping field is unified with other variables in struct page.
|
|
As well, if driver releases the page after isolation by VM, page->mapping
|
|
doesn't have stable value although it has PAGE_MAPPING_MOVABLE
|
|
(Look at __ClearPageMovable). But __PageMovable is cheap to catch whether
|
|
page is LRU or non-lru movable once the page has been isolated. Because
|
|
LRU pages never can have PAGE_MAPPING_MOVABLE in page->mapping. It is also
|
|
good for just peeking to test non-lru movable pages before more expensive
|
|
checking with lock_page in pfn scanning to select victim.
|
|
|
|
For guaranteeing non-lru movable page, VM provides PageMovable function.
|
|
Unlike __PageMovable, PageMovable functions validates page->mapping and
|
|
mapping->a_ops->isolate_page under lock_page. The lock_page prevents sudden
|
|
destroying of page->mapping.
|
|
|
|
Driver using __SetPageMovable should clear the flag via __ClearMovablePage
|
|
under page_lock before the releasing the page.
|
|
|
|
* PG_isolated
|
|
|
|
To prevent concurrent isolation among several CPUs, VM marks isolated page
|
|
as PG_isolated under lock_page. So if a CPU encounters PG_isolated non-lru
|
|
movable page, it can skip it. Driver doesn't need to manipulate the flag
|
|
because VM will set/clear it automatically. Keep in mind that if driver
|
|
sees PG_isolated page, it means the page have been isolated by VM so it
|
|
shouldn't touch page.lru field.
|
|
PG_isolated is alias with PG_reclaim flag so driver shouldn't use the flag
|
|
for own purpose.
|
|
|
|
Christoph Lameter, May 8, 2006.
|
|
Minchan Kim, Mar 28, 2016.
|