Commit | Line | Data |
---|---|---|
1b7599b5 MR |
1 | .. _page_migration: |
2 | ||
3 | ============== | |
a48d07af | 4 | Page migration |
1b7599b5 | 5 | ============== |
a48d07af | 6 | |
50aab9b1 RC |
7 | Page migration allows moving the physical location of pages between |
8 | nodes in a NUMA system while the process is running. This means that the | |
a48d07af CL |
9 | virtual addresses that the process sees do not change. However, the |
10 | system rearranges the physical location of those pages. | |
11 | ||
50aab9b1 RC |
12 | Also see :ref:`Heterogeneous Memory Management (HMM) <hmm>` |
13 | for migrating pages to or from device private memory. | |
14 | ||
15 | The main intent of page migration is to reduce the latency of memory accesses | |
a48d07af CL |
16 | by moving pages near to the processor where the process accessing that memory |
17 | is running. | |
18 | ||
19 | Page migration allows a process to manually relocate the node on which its | |
20 | pages are located through the MF_MOVE and MF_MOVE_ALL options while setting | |
50aab9b1 | 21 | a new memory policy via mbind(). The pages of a process can also be relocated |
a48d07af | 22 | from another process using the sys_migrate_pages() function call. The |
50aab9b1 | 23 | migrate_pages() function call takes two sets of nodes and moves pages of a |
a48d07af | 24 | process that are located on the from nodes to the destination nodes. |
b4fb3766 CL |
25 | Page migration functions are provided by the numactl package by Andi Kleen |
26 | (a version later than 0.9.3 is required. Get it from | |
50aab9b1 RC |
27 | https://github.com/numactl/numactl.git). numactl provides libnuma |
28 | which provides an interface similar to other NUMA functionality for page | |
1b7599b5 | 29 | migration. cat ``/proc/<pid>/numa_maps`` allows an easy review of where the |
6acb2ece MK |
30 | pages of a process are located. See also the numa_maps documentation in the |
31 | proc(5) man page. | |
b4fb3766 CL |
32 | |
33 | Manual migration is useful if for example the scheduler has relocated | |
a48d07af CL |
34 | a process to a processor on a distant node. A batch scheduler or an |
35 | administrator may detect the situation and move the pages of the process | |
50aab9b1 | 36 | nearer to the new processor. The kernel itself only provides |
742755a1 CL |
37 | manual page migration support. Automatic page migration may be implemented |
38 | through user space processes that move pages. A special function call | |
39 | "move_pages" allows the moving of individual pages within a process. | |
50aab9b1 | 40 | For example, A NUMA profiler may obtain a log showing frequent off-node |
742755a1 CL |
41 | accesses and may use the result to move pages to more advantageous |
42 | locations. | |
a48d07af CL |
43 | |
44 | Larger installations usually partition the system using cpusets into | |
45 | sections of nodes. Paul Jackson has equipped cpusets with the ability to | |
21acb9ca | 46 | move pages when a task is moved to another cpuset (See |
50aab9b1 RC |
47 | :ref:`CPUSETS <cpusets>`). |
48 | Cpusets allow the automation of process locality. If a task is moved to | |
b4fb3766 CL |
49 | a new cpuset then also all its pages are moved with it so that the |
50 | performance of the process does not sink dramatically. Also the pages | |
51 | of processes in a cpuset are moved if the allowed memory nodes of a | |
52 | cpuset are changed. | |
a48d07af CL |
53 | |
54 | Page migration allows the preservation of the relative location of pages | |
55 | within a group of nodes for all migration techniques which will preserve a | |
56 | particular memory allocation pattern generated even after migrating a | |
57 | process. This is necessary in order to preserve the memory latencies. | |
58 | Processes will run with similar performance after migration. | |
59 | ||
60 | Page migration occurs in several steps. First a high level | |
b4fb3766 CL |
61 | description for those trying to use migrate_pages() from the kernel |
62 | (for userspace usage see the Andi Kleen's numactl package mentioned above) | |
63 | and then a low level description of how the low level details work. | |
a48d07af | 64 | |
1b7599b5 MR |
65 | In kernel use of migrate_pages() |
66 | ================================ | |
a48d07af CL |
67 | |
68 | 1. Remove pages from the LRU. | |
69 | ||
70 | Lists of pages to be migrated are generated by scanning over | |
71 | pages and moving them into lists. This is done by | |
b4fb3766 | 72 | calling isolate_lru_page(). |
50aab9b1 | 73 | Calling isolate_lru_page() increases the references to the page |
b4fb3766 | 74 | so that it cannot vanish while the page migration occurs. |
50aab9b1 | 75 | It also prevents the swapper or other scans from encountering |
b4fb3766 | 76 | the page. |
a48d07af | 77 | |
742755a1 CL |
78 | 2. We need to have a function of type new_page_t that can be |
79 | passed to migrate_pages(). This function should figure out | |
80 | how to allocate the correct new page given the old page. | |
a48d07af CL |
81 | |
82 | 3. The migrate_pages() function is called which attempts | |
742755a1 CL |
83 | to do the migration. It will call the function to allocate |
84 | the new page for each page that is considered for | |
85 | moving. | |
a48d07af | 86 | |
1b7599b5 MR |
87 | How migrate_pages() works |
88 | ========================= | |
a48d07af | 89 | |
b4fb3766 CL |
90 | migrate_pages() does several passes over its list of pages. A page is moved |
91 | if all references to a page are removable at the time. The page has | |
92 | already been removed from the LRU via isolate_lru_page() and the refcount | |
93 | is increased so that the page cannot be freed while page migration occurs. | |
a48d07af CL |
94 | |
95 | Steps: | |
96 | ||
50aab9b1 | 97 | 1. Lock the page to be migrated. |
a48d07af | 98 | |
b93b0163 | 99 | 2. Ensure that writeback is complete. |
a48d07af | 100 | |
cf4b769a | 101 | 3. Lock the new page that we want to move to. It is locked so that accesses to |
94ebdd28 | 102 | this (not yet up-to-date) page immediately block while the move is in progress. |
a48d07af | 103 | |
cf4b769a | 104 | 4. All the page table references to the page are converted to migration |
7a14239a HD |
105 | entries. This decreases the mapcount of a page. If the resulting |
106 | mapcount is not zero then we do not migrate the page. All user space | |
50aab9b1 RC |
107 | processes that attempt to access the page will now wait on the page lock |
108 | or wait for the migration page table entry to be removed. | |
a48d07af | 109 | |
b93b0163 MW |
110 | 5. The i_pages lock is taken. This will cause all processes trying |
111 | to access the page via the mapping to block on the spinlock. | |
a48d07af | 112 | |
50aab9b1 RC |
113 | 6. The refcount of the page is examined and we back out if references remain. |
114 | Otherwise, we know that we are the only one referencing this page. | |
a48d07af | 115 | |
cf4b769a | 116 | 7. The radix tree is checked and if it does not contain the pointer to this |
8d3c138b | 117 | page then we back out because someone else modified the radix tree. |
a48d07af | 118 | |
cf4b769a HD |
119 | 8. The new page is prepped with some settings from the old page so that |
120 | accesses to the new page will discover a page with the correct settings. | |
121 | ||
8d3c138b | 122 | 9. The radix tree is changed to point to the new page. |
a48d07af | 123 | |
b93b0163 | 124 | 10. The reference count of the old page is dropped because the address space |
8d3c138b | 125 | reference is gone. A reference to the new page is established because |
b93b0163 | 126 | the new page is referenced by the address space. |
a48d07af | 127 | |
b93b0163 MW |
128 | 11. The i_pages lock is dropped. With that lookups in the mapping |
129 | become possible again. Processes will move from spinning on the lock | |
8d3c138b | 130 | to sleeping on the locked new page. |
a48d07af | 131 | |
8d3c138b | 132 | 12. The page contents are copied to the new page. |
a48d07af | 133 | |
8d3c138b | 134 | 13. The remaining page flags are copied to the new page. |
a48d07af | 135 | |
8d3c138b CL |
136 | 14. The old page flags are cleared to indicate that the page does |
137 | not provide any information anymore. | |
a48d07af | 138 | |
8d3c138b | 139 | 15. Queued up writeback on the new page is triggered. |
a48d07af | 140 | |
50aab9b1 RC |
141 | 16. If migration entries were inserted into the page table, then replace them |
142 | with real ptes. Doing so will enable access for user space processes not | |
143 | already waiting for the page lock. | |
b4fb3766 | 144 | |
50aab9b1 | 145 | 17. The page locks are dropped from the old and new page. |
8d3c138b CL |
146 | Processes waiting on the page lock will redo their page faults |
147 | and will reach the new page. | |
b4fb3766 | 148 | |
50aab9b1 RC |
149 | 18. The new page is moved to the LRU and can be scanned by the swapper, |
150 | etc. again. | |
b4fb3766 | 151 | |
1b7599b5 MR |
152 | Non-LRU page migration |
153 | ====================== | |
bda807d4 | 154 | |
50aab9b1 RC |
155 | Although migration originally aimed for reducing the latency of memory accesses |
156 | for NUMA, compaction also uses migration to create high-order pages. | |
bda807d4 MK |
157 | |
158 | Current problem of the implementation is that it is designed to migrate only | |
50aab9b1 | 159 | *LRU* pages. However, there are potential non-LRU pages which can be migrated |
bda807d4 MK |
160 | in drivers, for example, zsmalloc, virtio-balloon pages. |
161 | ||
162 | For virtio-balloon pages, some parts of migration code path have been hooked | |
163 | up and added virtio-balloon specific functions to intercept migration logics. | |
164 | It's too specific to a driver so other drivers who want to make their pages | |
50aab9b1 | 165 | movable would have to add their own specific hooks in the migration path. |
bda807d4 | 166 | |
50aab9b1 | 167 | To overcome the problem, VM supports non-LRU page migration which provides |
bda807d4 | 168 | generic functions for non-LRU movable pages without driver specific hooks |
50aab9b1 | 169 | in the migration path. |
bda807d4 | 170 | |
50aab9b1 | 171 | If a driver wants to make its pages movable, it should define three functions |
bda807d4 MK |
172 | which are function pointers of struct address_space_operations. |
173 | ||
1b7599b5 | 174 | 1. ``bool (*isolate_page) (struct page *page, isolate_mode_t mode);`` |
bda807d4 | 175 | |
50aab9b1 RC |
176 | What VM expects from isolate_page() function of driver is to return *true* |
177 | if driver isolates the page successfully. On returning true, VM marks the page | |
1b7599b5 MR |
178 | as PG_isolated so concurrent isolation in several CPUs skip the page |
179 | for isolation. If a driver cannot isolate the page, it should return *false*. | |
bda807d4 | 180 | |
1b7599b5 | 181 | Once page is successfully isolated, VM uses page.lru fields so driver |
50aab9b1 | 182 | shouldn't expect to preserve values in those fields. |
bda807d4 | 183 | |
1b7599b5 MR |
184 | 2. ``int (*migratepage) (struct address_space *mapping,`` |
185 | | ``struct page *newpage, struct page *oldpage, enum migrate_mode);`` | |
bda807d4 | 186 | |
50aab9b1 RC |
187 | After isolation, VM calls migratepage() of driver with the isolated page. |
188 | The function of migratepage() is to move the contents of the old page to the | |
189 | new page | |
1b7599b5 MR |
190 | and set up fields of struct page newpage. Keep in mind that you should |
191 | indicate to the VM the oldpage is no longer movable via __ClearPageMovable() | |
50aab9b1 | 192 | under page_lock if you migrated the oldpage successfully and returned |
1b7599b5 MR |
193 | MIGRATEPAGE_SUCCESS. If driver cannot migrate the page at the moment, driver |
194 | can return -EAGAIN. On -EAGAIN, VM will retry page migration in a short time | |
50aab9b1 RC |
195 | because VM interprets -EAGAIN as "temporary migration failure". On returning |
196 | any error except -EAGAIN, VM will give up the page migration without | |
197 | retrying. | |
bda807d4 | 198 | |
50aab9b1 | 199 | Driver shouldn't touch the page.lru field while in the migratepage() function. |
bda807d4 | 200 | |
1b7599b5 | 201 | 3. ``void (*putback_page)(struct page *);`` |
bda807d4 | 202 | |
50aab9b1 RC |
203 | If migration fails on the isolated page, VM should return the isolated page |
204 | to the driver so VM calls the driver's putback_page() with the isolated page. | |
205 | In this function, the driver should put the isolated page back into its own data | |
1b7599b5 | 206 | structure. |
a48d07af | 207 | |
d7482c0d | 208 | Non-LRU movable page flags |
bda807d4 | 209 | |
50aab9b1 | 210 | There are two page flags for supporting non-LRU movable page. |
bda807d4 | 211 | |
1b7599b5 | 212 | * PG_movable |
bda807d4 | 213 | |
50aab9b1 | 214 | Driver should use the function below to make page movable under page_lock:: |
bda807d4 MK |
215 | |
216 | void __SetPageMovable(struct page *page, struct address_space *mapping) | |
217 | ||
1b7599b5 MR |
218 | It needs argument of address_space for registering migration |
219 | family functions which will be called by VM. Exactly speaking, | |
50aab9b1 RC |
220 | PG_movable is not a real flag of struct page. Rather, VM |
221 | reuses the page->mapping's lower bits to represent it:: | |
bda807d4 MK |
222 | |
223 | #define PAGE_MAPPING_MOVABLE 0x2 | |
224 | page->mapping = page->mapping | PAGE_MAPPING_MOVABLE; | |
225 | ||
1b7599b5 | 226 | so driver shouldn't access page->mapping directly. Instead, driver should |
50aab9b1 RC |
227 | use page_mapping() which masks off the low two bits of page->mapping under |
228 | page lock so it can get the right struct address_space. | |
229 | ||
230 | For testing of non-LRU movable pages, VM supports __PageMovable() function. | |
231 | However, it doesn't guarantee to identify non-LRU movable pages because | |
232 | the page->mapping field is unified with other variables in struct page. | |
233 | If the driver releases the page after isolation by VM, page->mapping | |
234 | doesn't have a stable value although it has PAGE_MAPPING_MOVABLE set | |
235 | (look at __ClearPageMovable). But __PageMovable() is cheap to call whether | |
236 | page is LRU or non-LRU movable once the page has been isolated because LRU | |
237 | pages can never have PAGE_MAPPING_MOVABLE set in page->mapping. It is also | |
238 | good for just peeking to test non-LRU movable pages before more expensive | |
239 | checking with lock_page() in pfn scanning to select a victim. | |
240 | ||
241 | For guaranteeing non-LRU movable page, VM provides PageMovable() function. | |
242 | Unlike __PageMovable(), PageMovable() validates page->mapping and | |
243 | mapping->a_ops->isolate_page under lock_page(). The lock_page() prevents | |
244 | sudden destroying of page->mapping. | |
245 | ||
246 | Drivers using __SetPageMovable() should clear the flag via | |
247 | __ClearMovablePage() under page_lock() before the releasing the page. | |
1b7599b5 MR |
248 | |
249 | * PG_isolated | |
250 | ||
251 | To prevent concurrent isolation among several CPUs, VM marks isolated page | |
50aab9b1 RC |
252 | as PG_isolated under lock_page(). So if a CPU encounters PG_isolated |
253 | non-LRU movable page, it can skip it. Driver doesn't need to manipulate the | |
254 | flag because VM will set/clear it automatically. Keep in mind that if the | |
255 | driver sees a PG_isolated page, it means the page has been isolated by the | |
256 | VM so it shouldn't touch the page.lru field. | |
257 | The PG_isolated flag is aliased with the PG_reclaim flag so drivers | |
258 | shouldn't use PG_isolated for its own purposes. | |
bda807d4 | 259 | |
1a5bae25 AK |
260 | Monitoring Migration |
261 | ===================== | |
262 | ||
263 | The following events (counters) can be used to monitor page migration. | |
264 | ||
265 | 1. PGMIGRATE_SUCCESS: Normal page migration success. Each count means that a | |
5d39a7eb BW |
266 | page was migrated. If the page was a non-THP and non-hugetlb page, then |
267 | this counter is increased by one. If the page was a THP or hugetlb, then | |
268 | this counter is increased by the number of THP or hugetlb subpages. | |
269 | For example, migration of a single 2MB THP that has 4KB-size base pages | |
270 | (subpages) will cause this counter to increase by 512. | |
1a5bae25 AK |
271 | |
272 | 2. PGMIGRATE_FAIL: Normal page migration failure. Same counting rules as for | |
50aab9b1 | 273 | PGMIGRATE_SUCCESS, above: this will be increased by the number of subpages, |
5d39a7eb | 274 | if it was a THP or hugetlb. |
1a5bae25 AK |
275 | |
276 | 3. THP_MIGRATION_SUCCESS: A THP was migrated without being split. | |
277 | ||
278 | 4. THP_MIGRATION_FAIL: A THP could not be migrated nor it could be split. | |
279 | ||
280 | 5. THP_MIGRATION_SPLIT: A THP was migrated, but not as such: first, the THP had | |
281 | to be split. After splitting, a migration retry was used for it's sub-pages. | |
282 | ||
283 | THP_MIGRATION_* events also update the appropriate PGMIGRATE_SUCCESS or | |
284 | PGMIGRATE_FAIL events. For example, a THP migration failure will cause both | |
285 | THP_MIGRATION_FAIL and PGMIGRATE_FAIL to increase. | |
286 | ||
bda807d4 MK |
287 | Christoph Lameter, May 8, 2006. |
288 | Minchan Kim, Mar 28, 2016. |