blob: 964595481af683a7a9c344182ca707fd1c2a33fa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001Started Jan 2000 by Kanoj Sarcar <kanoj@sgi.com>
2
Mel Gormand0164ad2015-11-06 16:28:21 -08003Memory balancing is needed for !__GFP_ATOMIC and !__GFP_KSWAPD_RECLAIM as
4well as for non __GFP_IO allocations.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005
Mel Gormand0164ad2015-11-06 16:28:21 -08006The first reason why a caller may avoid reclaim is that the caller can not
7sleep due to holding a spinlock or is in interrupt context. The second may
8be that the caller is willing to fail the allocation without incurring the
9overhead of page reclaim. This may happen for opportunistic high-order
10allocation requests that have order-0 fallback options. In such cases,
11the caller may also wish to avoid waking kswapd.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012
13__GFP_IO allocation requests are made to prevent file system deadlocks.
14
15In the absence of non sleepable allocation requests, it seems detrimental
16to be doing balancing. Page reclamation can be kicked off lazily, that
17is, only when needed (aka zone free memory is 0), instead of making it
18a proactive process.
19
20That being said, the kernel should try to fulfill requests for direct
21mapped pages from the direct mapped pool, instead of falling back on
22the dma pool, so as to keep the dma pool filled for dma requests (atomic
23or not). A similar argument applies to highmem and direct mapped pages.
24OTOH, if there is a lot of free dma pages, it is preferable to satisfy
25regular memory requests by allocating one from the dma pool, instead
26of incurring the overhead of regular zone balancing.
27
28In 2.2, memory balancing/page reclamation would kick off only when the
29_total_ number of free pages fell below 1/64 th of total memory. With the
30right ratio of dma and regular memory, it is quite possible that balancing
31would not be done even when the dma zone was completely empty. 2.2 has
32been running production machines of varying memory sizes, and seems to be
33doing fine even with the presence of this problem. In 2.3, due to
34HIGHMEM, this problem is aggravated.
35
36In 2.3, zone balancing can be done in one of two ways: depending on the
37zone size (and possibly of the size of lower class zones), we can decide
38at init time how many free pages we should aim for while balancing any
39zone. The good part is, while balancing, we do not need to look at sizes
40of lower class zones, the bad part is, we might do too frequent balancing
41due to ignoring possibly lower usage in the lower class zones. Also,
42with a slight change in the allocation routine, it is possible to reduce
43the memclass() macro to be a simple equality.
44
45Another possible solution is that we balance only when the free memory
46of a zone _and_ all its lower class zones falls below 1/64th of the
47total memory in the zone and its lower class zones. This fixes the 2.2
48balancing problem, and stays as close to 2.2 behavior as possible. Also,
49the balancing algorithm works the same way on the various architectures,
50which have different numbers and types of zones. If we wanted to get
51fancy, we could assign different weights to free pages in different
52zones in the future.
53
54Note that if the size of the regular zone is huge compared to dma zone,
55it becomes less significant to consider the free dma pages while
56deciding whether to balance the regular zone. The first solution
57becomes more attractive then.
58
59The appended patch implements the second solution. It also "fixes" two
60problems: first, kswapd is woken up as in 2.2 on low memory conditions
61for non-sleepable allocations. Second, the HIGHMEM zone is also balanced,
62so as to give a fighting chance for replace_with_highmem() to get a
63HIGHMEM page, as well as to ensure that HIGHMEM allocations do not
64fall back into regular zone. This also makes sure that HIGHMEM pages
65are not leaked (for example, in situations where a HIGHMEM page is in
66the swapcache but is not being used by anyone)
67
68kswapd also needs to know about the zones it should balance. kswapd is
69primarily needed in a situation where balancing can not be done,
70probably because all allocation requests are coming from intr context
71and all process contexts are sleeping. For 2.3, kswapd does not really
72need to balance the highmem zone, since intr context does not request
73highmem pages. kswapd looks at the zone_wake_kswapd field in the zone
74structure to decide whether a zone needs balancing.
75
76Page stealing from process memory and shm is done if stealing the page would
77alleviate memory pressure on any zone in the page's node that has fallen below
78its watermark.
79
Mel Gorman41858962009-06-16 15:32:12 -070080watemark[WMARK_MIN/WMARK_LOW/WMARK_HIGH]/low_on_memory/zone_wake_kswapd: These
81are per-zone fields, used to determine when a zone needs to be balanced. When
82the number of pages falls below watermark[WMARK_MIN], the hysteric field
83low_on_memory gets set. This stays set till the number of free pages becomes
84watermark[WMARK_HIGH]. When low_on_memory is set, page allocation requests will
85try to free some pages in the zone (providing GFP_WAIT is set in the request).
86Orthogonal to this, is the decision to poke kswapd to free some zone pages.
87That decision is not hysteresis based, and is done when the number of free
88pages is below watermark[WMARK_LOW]; in which case zone_wake_kswapd is also set.
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90
91(Good) Ideas that I have heard:
921. Dynamic experience should influence balancing: number of failed requests
93for a zone can be tracked and fed into the balancing scheme (jalvo@mbay.net)
942. Implement a replace_with_highmem()-like replace_with_regular() to preserve
95dma pages. (lkd@tantalophile.demon.co.uk)