OOM detection rework v2
Subsystems (5)
Michal Hocko
reviewercover OOM detection rework v2
Hi,
this is a second version of the the patchset. The previous version was posted here [1]. Changes since the last time are not really huge. The backoff calculation was de-obfuscated by using DIV_ROUND_UP and one theoretical bug for __GFP_NOFAIL and costly requests was fixed.
As pointed by Linus [2][3] relying on zone_reclaimable as a way to communicate the reclaim progress is rater dubious. I tend to agree, not only it is really obscure, it is not hard to imagine cases where a single page freed in the loop keeps all the reclaimers looping without getting any progress because their gfp_mask wouldn't allow to get that page anyway (e.g. single GFP_ATOMIC alloc and free loop). This is rather rare so it doesn't happen in the practice but the current logic which we have is rather obscure and hard to follow a also non-deterministic.
This is an attempt to make the OOM detection more deterministic and easier to follow because each reclaimer basically tracks its own progress which is implemented at the page allocator layer rather spread out between the allocator and the reclaim. The more on the implementation is described in the first patch.
I have tested several different scenarios but it should be clear that testing OOM killer is quite hard to be representative. There is usually a tiny gap between almost OOM and full blown OOM which is often time sensitive. Anyway, I have tested the following 3 scenarios and I would appreciate if there are more to test.
Testing environment: a virtual machine with 2G of RAM and 2CPUs without any swap to make the OOM more deterministic.
1) 2 writers (each doing dd with 4M blocks to an xfs partition with 1G size, removes the files and starts over again) running in parallel for 10s to build up a lot of dirty pages when 100 parallel mem_eaters (anon private populated mmap which waits until it gets signal) with 80M each.
This causes an OOM flood of course and I have compared both patched and unpatched kernels. The test is considered finished after there are no OOM conditions detected. This should tell us whether there are any excessive kills or some of them premature:
* base kernel
$ grep "Killed process" base-oom-run.log | tail -n1 [ 836.589319] Killed process 3035 (mem_eater) total-vm:85852kB, anon-rss:81996kB, file-rss:344kB $ grep "invoked oom-killer" base-oom-run.log | wc -l 78 $ grep "DMA32.*all_unreclaimable? no" base-oom-run.log | wc -l 0
* patched kernel
$ grep "Killed process" patched-oom-run.log | tail -n1 [ 843.281009] Killed process 2998 (mem_eater) total-vm:85852kB, anon-rss:82000kB, file-rss:4kB $ grep "invoked oom-killer" patched-oom-run.log | wc -l 77 $ grep "DMA32.*all_unreclaimable? no" patched-oom-run.log | wc -l 0
So they have finished in a comparable time and killed the very similar number of processes and there doesn't seem to be any case where the patched kernel would have DMA32 zone considered reclaimable.
2) 2 writers again with 10s of run and then 10 mem_eaters to consume as much memory as possible without triggering the OOM killer. This required a lot of tuning but I've considered 3 consecutive runs without OOM as a success.
* base kernel
size=$(awk '/MemFree/{printf "%dK", ($2/10)-(14*1024)}' /proc/meminfo)
* patched kernel
size=$(awk '/MemFree/{printf "%dK", ($2/10)-(7500)}' /proc/meminfo)
So it seems that the patched kernel handled the low mem conditions better and fired OOM killer later.
3) Costly high-order allocations with a limited amount of memory. Start 10 memeaters in parallel each with
size=$(awk '/MemTotal/{printf "%d\n", $2/10}' /proc/meminfo) This will cause an OOM killer which will kill one of them which will free up 200M and then try to use all the remaining space for hugetlb pages. See how many of them will pass kill everything, wait 2s and try again. This tests whether we do not fail __GFP_REPEAT costly allocations too early now.
* base kernel
$ sort base-hugepages.log | uniq -c
1 66
19 67
20 Trying to allocate 74* patched kernel
$ sort patched-hugepages.log | uniq -c
1 66
19 67
20 Trying to allocate 74This also doesn't look very bad but this particular test is quite timing sensitive.
The above results do seem optimistic but more loads should be tested obviously. I would really appreciate a feedback on the approach I have chosen before I go into more tuning. Is this viable way to go?
[1] http://lkml.kernel.org/r/[email protected]
[2] http://lkml.kernel.org/r/CA+55aFwapaED7JV6zm-NVkP-jKie+eQ1vDXWrKD=SkbshZSgmw@mail.gmail.com
[3] http://lkml.kernel.org/r/CA+55aFxwg=vS2nrXsQhAUzPQDGb8aQpZi0M7UUh21ftBo-z46Q@mail.gmail.com
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Michal Hocko
reviewerRFC 1/3 mm, oom: refactor oom detection
From: Michal Hocko <[email protected]>
__alloc_pages_slowpath has traditionally relied on the direct reclaim and did_some_progress as an indicator that it makes sense to retry allocation rather than declaring OOM. shrink_zones had to rely on zone_reclaimable if shrink_zone didn't make any progress to prevent from a premature OOM killer invocation - the LRU might be full of dirty or writeback pages and direct reclaim cannot clean those up.
zone_reclaimable allows to rescan the reclaimable lists several times and restart if a page is freed. This is really subtle behavior and it might lead to a livelock when a single freed page keeps allocator looping but the current task will not be able to allocate that single page. OOM killer would be more appropriate than looping without any progress for unbounded amount of time.
This patch changes OOM detection logic and pulls it out from shrink_zone which is too low to be appropriate for any high level decisions such as OOM which is per zonelist property. It is __alloc_pages_slowpath which knows how many attempts have been done and what was the progress so far therefore it is more appropriate to implement this logic.
The new heuristic tries to be more deterministic and easier to follow. It builds on an assumption that retrying makes sense only if the currently reclaimable memory + free pages would allow the current allocation request to succeed (as per __zone_watermark_ok) at least for one zone in the usable zonelist.
This alone wouldn't be sufficient, though, because the writeback might get stuck and reclaimable pages might be pinned for a really long time or even depend on the current allocation context. Therefore there is a feedback mechanism implemented which reduces the reclaim target after each reclaim round without any progress. This means that we should eventually converge to only NR_FREE_PAGES as the target and fail on the wmark check and proceed to OOM. The backoff is simple and linear with 1/16 of the reclaimable pages for each round without any progress. We are optimistic and reset counter for successful reclaim rounds.
Costly high order pages mostly preserve their semantic and those without __GFP_REPEAT fail right away while those which have the flag set will back off after the amount of reclaimable pages reaches equivalent of the requested order. The only difference is that if there was no progress during the reclaim we rely on zone watermark check. This is more logical thing to do than previous 1<<order attempts which were a result of zone_reclaimable faking the progress.
--- include/linux/swap.h | 1 + mm/page_alloc.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++------ mm/vmscan.c | 13 ++-------- 3 files changed, 66 insertions(+), 18 deletions(-)
include/linux/swap.h +1 -0
@@ -316,6 +316,7 @@ extern void lru_cache_add_active_or_unevictable(struct page *page, struct vm_area_struct *vma);/* linux/mm/vmscan.c */ +extern unsigned long zone_reclaimable_pages (struct zone *zone);extern unsigned long try_to_free_pages (struct zonelist *zonelist,int order,gfp_t gfp_mask,nodemask_t *mask);extern int __isolate_lru_page (struct page *page,isolate_mode_t mode);
mm/page_alloc.c +63 -7
96 lines not on this page · raw message
mm/vmscan.c +2 -11
@@ -192,7 +192,7 @@ static bool sane_reclaim(struct scan_control *sc) }#endif -static unsigned long zone_reclaimable_pages (struct zone *zone) +unsigned long zone_reclaimable_pages (struct zone *zone) {unsigned long nr;
@@ -2594,10 +2594,6 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)if (shrink_zone (zone, sc,zone_idx (zone) == classzone_idx)) reclaimable = true; - -if (global_reclaim (sc) && - !reclaimable &&zone_reclaimable (zone)) - reclaimable = true; }/*
@@ -2631,7 +2627,6 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,int initial_priority = sc->priority;unsigned long total_scanned =0 ;unsigned long writeback_threshold; -bool zones_reclaimable; retry:delayacct_freepages_start ();
@@ -2642,7 +2637,7 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,vmpressure_prio (sc->gfp_mask, sc->target_mem_cgroup, sc->priority); sc->nr_scanned =0 ; - zones_reclaimable =shrink_zones (zonelist, sc); +shrink_zones (zonelist, sc); total_scanned += sc->nr_scanned;if (sc->nr_reclaimed >= sc->nr_to_reclaim)
@@ -2689,10 +2684,6 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist, goto retry; } -/* Any of the zones still reclaimable? Don't OOM. */ -if (zones_reclaimable) -return 1 ; -return 0 ; }
Signature · 7 lines
2.6.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 1/3] mm, oom: refactor oom detection
Quoted 41 lines · Michal Hocko
mm/page_alloc.c +14
-4@@ -2992,6 +2992,13 @@ static inline bool is_thp_gfp_mask(gfp_t gfp_mask)return (gfp_mask & (GFP_TRANSHUGE | __GFP_KSWAPD_RECLAIM)) ==GFP_TRANSHUGE ; } +/* +* Number of backoff steps for potentially reclaimable pages if the direct reclaim +* cannot make any progress. Each step will reduce 1/MAX_STALL_BACKOFF of the +* reclaimable memory. +*/ +#define MAX_STALL_BACKOFF 16 +static inline struct page *__alloc_pages_slowpath (gfp_t gfp_mask,unsigned int order,struct alloc_context *ac)@@ -3004,6 +3011,9 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,enum migrate_mode migration_mode =MIGRATE_ASYNC ;bool deferred_compaction = false;int contended_compaction =COMPACT_CONTENDED_NONE ; +struct zone *zone; +struct zoneref *z; +int stall_backoff =0 ;/* * In the slowpath, we sanity check order to avoid ever trying to @@ -3155,13 +3165,57 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,if (gfp_mask & __GFP_NORETRY) goto noretry; -/* Keep reclaiming pages as long as there is reasonable progress */ +/* +* Do not retry high order allocations unless they are __GFP_REPEAT +* and even then do not retry endlessly unless explicitly told so +*/ pages_reclaimed += did_some_progress; -if ((did_some_progress && order <=PAGE_ALLOC_COSTLY_ORDER ) || - ((gfp_mask & __GFP_REPEAT) && pages_reclaimed < (1 << order))) { -/* Wait for some write requests to complete then retry */
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3180
Quoted 10 lines
mm/page_alloc.c +8
-2-wait_iff_congested (ac->preferred_zone,BLK_RW_ASYNC ,HZ /50 ); - goto retry; +if (order >PAGE_ALLOC_COSTLY_ORDER ) { +if (!(gfp_mask & __GFP_NOFAIL) && + (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) + goto noretry; + +if (did_some_progress) + goto retry; + }
First of all, thanks very much for attacking this issue!
I'm concerned that we'll reach stall_backoff == MAX_STALL_BACKOFF too quickly if the wait_iff_congested() is removed. While not immediately being available for reclaim, this has at least partially stalled in the past which may have resulted in external memory freeing. I'm wondering if it would make sense to keep if nothing more than to avoid an immediate retry.
Quoted 9 lines
mm/page_alloc.c +9
-0+ +/* +* Be optimistic and consider all pages on reclaimable LRUs as usable +* but make sure we converge to OOM if we cannot make any progress after +* multiple consecutive failed attempts. +*/ +if (did_some_progress) + stall_backoff =0 ; +else
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3199
Quoted 10 lines
mm/page_alloc.c +10
-0+ stall_backoff =min (stall_backoff+1 ,MAX_STALL_BACKOFF ); + +/* +* Keep reclaiming pages while there is a chance this will lead somewhere. +* If none of the target zones can satisfy our allocation request even +* if all reclaimable pages are considered then we are screwed and have +* to go OOM. +*/ +for_each_zone_zonelist_nodemask (zone, z, ac->zonelist, ac->high_zoneidx, ac->nodemask) { +unsigned long free =zone_page_state (zone,NR_FREE_PAGES );
This is concerning, I would think that you would want to use zone_page_state_snapshot() at the very list for when stall_backoff == MAX_STALL_BACKOFF.
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3205
Quoted 6 lines
mm/page_alloc.c +6
-0+unsigned long reclaimable; +unsigned long target; + + reclaimable =zone_reclaimable_pages (zone) + +zone_page_state (zone,NR_ISOLATED_FILE ) + +zone_page_state (zone,NR_ISOLATED_ANON );
Does NR_ISOLATED_ANON mean anything relevant here in swapless environments?
Quoted 42 lines
mm/page_alloc.c +16
-1+ target = reclaimable; + target -=DIV_ROUND_UP (stall_backoff * target,MAX_STALL_BACKOFF ); + target += free; + +/* +* Would the allocation succeed if we reclaimed the whole target? +*/ +if (__zone_watermark_ok (zone, order,min_wmark_pages (zone), + ac->high_zoneidx, alloc_flags, target)) { +/* Wait for some write requests to complete then retry */ +wait_iff_congested (zone,BLK_RW_ASYNC ,HZ /50 ); + goto retry; + } }/* Reclaim has failed us, start killing things */ @@ -3170,8 +3224,10 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, goto got_pg;/* Retry as long as the OOM killer is making progress */ -if (did_some_progress) +if (did_some_progress) { + stall_backoff =0 ; goto retry; + } noretry:/* mm/vmscan.c +1
-1@@ -192,7 +192,7 @@ static bool sane_reclaim(struct scan_control *sc) }#endif -static unsigned long zone_reclaimable_pages (struct zone *zone) +unsigned long zone_reclaimable_pages (struct zone *zone) {unsigned long nr;
mm/vmscan.c static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc) · line 2599
Quoted 10 lines
mm/vmscan.c +0
-4@@ -2594,10 +2594,6 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)if (shrink_zone (zone, sc,zone_idx (zone) == classzone_idx)) reclaimable = true; - -if (global_reclaim (sc) && - !reclaimable &&zone_reclaimable (zone)) - reclaimable = true; }/*
It's possible to just make shrink_zones() void and drop the reclaimable variable.
Otherwise looks good!
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 1/3] mm, oom: refactor oom detection
Quoted 1 line · David Rientjes
On Wed, 18 Nov 2015, Michal Hocko wrote:
[...]
Quoted 26 lines
Quoted 13 lines
(quoted diff) +4
-4@@ -3155,13 +3165,57 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, if (gfp_mask & __GFP_NORETRY) goto noretry; - /* Keep reclaiming pages as long as there is reasonable progress */ + /* + * Do not retry high order allocations unless they are __GFP_REPEAT + * and even then do not retry endlessly unless explicitly told so + */ pages_reclaimed += did_some_progress; - if ((did_some_progress && order <= PAGE_ALLOC_COSTLY_ORDER) || - ((gfp_mask & __GFP_REPEAT) && pages_reclaimed < (1 << order))) { - /* Wait for some write requests to complete then retry */Review __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3180
Quoted 10 lines
(quoted diff) +8
-2- wait_iff_congested(ac->preferred_zone, BLK_RW_ASYNC, HZ/50); - goto retry; + if (order > PAGE_ALLOC_COSTLY_ORDER) { + if (!(gfp_mask & __GFP_NOFAIL) && + (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1<<order))) + goto noretry; + + if (did_some_progress) + goto retry; + }First of all, thanks very much for attacking this issue!
Quoted 6 lines
I'm concerned that we'll reach
stall_backoff==MAX_STALL_BACKOFFtoo quickly if thewait_iff_congested()is removed. While not immediately being available for reclaim, this has at least partially stalled in the past which may have resulted in external memory freeing. I'm wondering if it would make sense to keep if nothing more than to avoid an immediate retry.
My experiments show that wait_iff_congested slept only very rarely if at all (even for loads with a heavy IO). There might be other loads where it really hits, though. If you have any of those I would be more than happy if you could share them or at least test them with these patches.
If you are concerned about removed wait_iff_congested for costly __GFP_REPEAT allocations then the follow up patch changes that to use a common sleep&retry logic.
Quoted 15 lines
Quoted 15 lines
(quoted diff) +15
-0+ + /* + * Be optimistic and consider all pages on reclaimable LRUs as usable + * but make sure we converge to OOM if we cannot make any progress after + * multiple consecutive failed attempts. + */ + if (did_some_progress) + stall_backoff = 0; + else + stall_backoff = min(stall_backoff+1, MAX_STALL_BACKOFF); + + /* + * Keep reclaiming pages while there is a chance this will lead somewhere. + * If none of the target zones can satisfy our allocation request even + * if all reclaimable pages are considered then we are screwed and have
Quoted 8 lines
Review __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3199
Quoted 4 lines
(quoted diff) +4
-0+ * to go OOM. + */ + for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx, ac->nodemask) { + unsigned long free = zone_page_state(zone, NR_FREE_PAGES);This is concerning, I would think that you would want to use
zone_page_state_snapshot()at the very list for whenstall_backoff==MAX_STALL_BACKOFF.
OK, this is a fair point. In an extreme case where vmstat counters are way outdated we might loop endlessly. I will just use _snapshot variant. The overhead shouldn't be a concern as this is a slow path.
Other counters are using backoff so they do not need this special treatment.
Quoted 9 lines
Review __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3205
Quoted 6 lines
(quoted diff) +6
-0+ unsigned long reclaimable; + unsigned long target; + + reclaimable = zone_reclaimable_pages(zone) + + zone_page_state(zone, NR_ISOLATED_FILE) + + zone_page_state(zone, NR_ISOLATED_ANON);Does
NR_ISOLATED_ANONmean anything relevant here in swapless environments?
It should be 0 so I didn't bother to check for swapless configuration.
[...]
Quoted 23 lines
Quoted 23 lines
mm/vmscan.c +1
-5@@ -192,7 +192,7 @@ static bool sane_reclaim(struct scan_control *sc) }#endif -static unsigned long zone_reclaimable_pages (struct zone *zone) +unsigned long zone_reclaimable_pages (struct zone *zone) {unsigned long nr;@@ -2594,10 +2594,6 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)if (shrink_zone (zone, sc,zone_idx (zone) == classzone_idx)) reclaimable = true; - -if (global_reclaim (sc) && - !reclaimable &&zone_reclaimable (zone)) - reclaimable = true; }
Quoted 4 lines
mm/vmscan.c static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc) · line 2599
Quoted 1 line
mm/vmscan.c +0
-0/* It's possible to just make
shrink_zones()void and drop the reclaimable variable.
True, will do that.
Quoted 1 line
Otherwise looks good!
Thanks for the review!
Here is what I will fold it to the original patch
---
commit b8687e8406f4ec1b194b259acaea115711d319cd
Author: Michal Hocko <[email protected]> Date: Fri Nov 20 10:04:22 2015 +0100
fold me: mm, oom: refactor oom detection
[[email protected]: use zone_page_state_snapshot for NR_FREE_PAGES] [[email protected]: shrink_zones doesn't need to return anything]
mm/page_alloc.c +1 -1
@@ -3192,7 +3192,7 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,* to go OOM. */ for_each_zone_zonelist_nodemask (zone, z, ac->zonelist, ac->high_zoneidx, ac->nodemask) { -unsigned long free =zone_page_state (zone,NR_FREE_PAGES ); +unsigned long free =zone_page_state_snapshot (zone,NR_FREE_PAGES );unsigned long reclaimable;unsigned long target;
mm/vmscan.c +2 -10
@@ -2511,10 +2511,8 @@ static inline bool compaction_ready(struct zone *zone, int order)* * If a zone is deemed to be full of pinned pages then just give it a light * scan then give up on it. -* -* Returns true if a zone was reclaimable. */ -static bool shrink_zones (struct zonelist *zonelist,struct scan_control *sc) +static void shrink_zones (struct zonelist *zonelist,struct scan_control *sc) {struct zoneref *z;struct zone *zone;
@@ -2522,7 +2520,6 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)unsigned long nr_soft_scanned;gfp_t orig_mask;enum zone_type requested_highidx =gfp_zone (sc->gfp_mask); -bool reclaimable = false;/* * If the number of buffer_heads in the machine exceeds the maximum
@@ -2587,13 +2584,10 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc) &nr_soft_scanned); sc->nr_reclaimed += nr_soft_reclaimed; sc->nr_scanned += nr_soft_scanned; -if (nr_soft_reclaimed) - reclaimable = true;/* need some check for avoid more shrink_zone() */ } -if (shrink_zone (zone, sc,zone_idx (zone) == classzone_idx)) - reclaimable = true; +shrink_zone (zone, sc,zone_idx (zone)); }/*
@@ -2601,8 +2595,6 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)* promoted it to __GFP_HIGHMEM. */ sc->gfp_mask = orig_mask; - -return reclaimable; }/*
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 1/3] mm, oom: refactor oom detection
Quoted 10 lines · Michal Hocko
Quoted 9 lines
Review
Quoted 6 lines
(quoted diff) +6
-0+ unsigned long reclaimable; + unsigned long target; + + reclaimable = zone_reclaimable_pages(zone) + + zone_page_state(zone, NR_ISOLATED_FILE) + + zone_page_state(zone, NR_ISOLATED_ANON);Does
NR_ISOLATED_ANONmean anything relevant here in swapless environments?
Quoted 2 lines
It should be 0 so I didn't bother to check for swapless configuration.
I'm not sure I understand your point, memory compaction certainly increments NR_ISOLATED_ANON and that would be considered unreclaimable in a swapless environment, correct?
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 1/3] mm, oom: refactor oom detection
Quoted 12 lines · David Rientjes
Quoted 10 lines · Michal Hocko
Quoted 9 lines
Review
Quoted 6 lines
(quoted diff) +6
-0+ unsigned long reclaimable; + unsigned long target; + + reclaimable = zone_reclaimable_pages(zone) + + zone_page_state(zone, NR_ISOLATED_FILE) + + zone_page_state(zone, NR_ISOLATED_ANON);Does
NR_ISOLATED_ANONmean anything relevant here in swapless environments?
Quoted 6 lines
Quoted 2 lines
It should be 0 so I didn't bother to check for swapless configuration.
I'm not sure I understand your point, memory compaction certainly increments
NR_ISOLATED_ANONand that would be considered unreclaimable in a swapless environment, correct?
My bad. I have completely missed that compaction/migration is updating the counter as well. I would expect that the number shouldn't too large to matter but I guess it will be better to simply exclude it. I will fold this to the first patch.
Thanks
---
mm/page_alloc.c +4 -2
@@ -3197,8 +3197,10 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,unsigned long target; reclaimable =zone_reclaimable_pages (zone) + -zone_page_state (zone,NR_ISOLATED_FILE ) + -zone_page_state (zone,NR_ISOLATED_ANON ); +zone_page_state (zone,NR_ISOLATED_FILE ); +if (get_nr_swap_pages () >0 ) + reclaimable +=zone_page_state (zone,NR_ISOLATED_ANON ); + target = reclaimable; target -=DIV_ROUND_UP (stall_backoff * target,MAX_STALL_BACKOFF ); target += free;
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Johannes Weiner
maintainerRe: [RFC 1/3] mm, oom: refactor oom detection
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3202
Quoted 9 lines · Michal Hocko
mm/page_alloc.c +3
-2@@ -3197,8 +3197,10 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,unsigned long target; reclaimable =zone_reclaimable_pages (zone) + -zone_page_state (zone,NR_ISOLATED_FILE ) + -zone_page_state (zone,NR_ISOLATED_ANON ); +zone_page_state (zone,NR_ISOLATED_FILE ); +if (get_nr_swap_pages () >0 ) + reclaimable +=zone_page_state (zone,NR_ISOLATED_ANON );
Can you include the isolated counts in zone_reclaimable_pages()?
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 1/3] mm, oom: refactor oom detection
Quoted 4 lines · Johannes Weiner
Quoted 3 lines · Michal Hocko
mm/page_alloc.c +0
-0@@ -3197,8 +3197,10 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,unsigned long target;
Quoted 8 lines
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3202
Quoted 6 lines
mm/page_alloc.c +3
-2reclaimable =zone_reclaimable_pages (zone) + -zone_page_state (zone,NR_ISOLATED_FILE ) + -zone_page_state (zone,NR_ISOLATED_ANON ); +zone_page_state (zone,NR_ISOLATED_FILE ); +if (get_nr_swap_pages () >0 ) + reclaimable +=zone_page_state (zone,NR_ISOLATED_ANON );Can you include the isolated counts in
zone_reclaimable_pages()?
OK, this makes sense. NR_ISOLATED_* should be a temporary condition after which pages either get back to the LRU or they get migrated to a different location thus freed.
I will spin this intot a separate patch.
Thanks!
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Michal Hocko
reviewerRFC 2/3 mm: throttle on IO only when there are too many dirty and writeback pages
In reply to Michal HockoFrom: Michal Hocko <[email protected]>
wait_iff_congested has been used to throttle allocator before it retried another round of direct reclaim to allow the writeback to make some progress and prevent reclaim from looping over dirty/writeback pages without making any progress. We used to do congestion_wait before 0e093d99763e ("writeback: do not sleep on the congestion queue if there are no congested BDIs or if significant congestion is not being encountered in the current zone") but that led to undesirable stalls and sleeping for the full timeout even when the BDI wasn't congested. Hence wait_iff_congested was used instead. But it seems that even wait_iff_congested doesn't work as expected. We might have a small file LRU list with all pages dirty/writeback and yet the bdi is not congested so this is just a cond_resched in the end and can end up triggering pre mature OOM.
This patch replaces the unconditional wait_iff_congested by congestion_wait which is executed only if we _know_ that the last round of direct reclaim didn't make any progress and dirty+writeback pages are more than a half of the reclaimable pages on the zone which might be usable for our target allocation. This shouldn't reintroduce stalls fixed by 0e093d99763e because congestion_wait is called only when we are getting hopeless when sleeping is a better choice than OOM with many pages under IO.
--- mm/page_alloc.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
mm/page_alloc.c +14 -2
@@ -3212,8 +3212,20 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,*/ if (__zone_watermark_ok (zone, order,min_wmark_pages (zone), ac->high_zoneidx, alloc_flags, target)) { -/* Wait for some write requests to complete then retry */ -wait_iff_congested (zone,BLK_RW_ASYNC ,HZ /50 ); +unsigned long writeback =zone_page_state (zone,NR_WRITEBACK ), + dirty =zone_page_state (zone,NR_FILE_DIRTY ); + +/* +* If we didn't make any progress and have a lot of +* dirty + writeback pages then we should wait for +* an IO to complete to slow down the reclaim and +* prevent from pre mature OOM +*/ +if (!did_some_progress &&2 *(writeback + dirty) > reclaimable) +congestion_wait (BLK_RW_ASYNC ,HZ /10 ); +else +cond_resched (); + goto retry; } }
Signature · 7 lines
2.6.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 2/3] mm: throttle on IO only when there are too many dirty and writeback pages
Quoted 16 lines · Michal Hocko
From: Michal Hocko <[email protected]>
wait_iff_congestedhas been used to throttle allocator before it retried another round of direct reclaim to allow the writeback to make some progress and prevent reclaim from looping over dirty/writeback pages without making any progress. We used to docongestion_waitbefore0e093d99763e("writeback: do not sleep on the congestion queue if there are no congested BDIs or if significant congestion is not being encountered in the current zone") but that led to undesirable stalls and sleeping for the full timeout even when the BDI wasn't congested. Hencewait_iff_congestedwas used instead. But it seems that evenwait_iff_congesteddoesn't work as expected. We might have a small file LRU list with all pages dirty/writeback and yet the bdi is not congested so this is just acond_reschedin the end and can end up triggering pre mature OOM.
Quoted 9 lines
This patch replaces the unconditional
wait_iff_congestedbycongestion_waitwhich is executed only if we _know_ that the last round of direct reclaim didn't make any progress and dirty+writeback pages are more than a half of the reclaimable pages on the zone which might be usable for our target allocation. This shouldn't reintroduce stalls fixed by0e093d99763ebecausecongestion_waitis called only when we are getting hopeless when sleeping is a better choice than OOM with many pages under IO.
Why HZ/10 instead of HZ/50?
Quoted 16 lines
Signed-off-by Michal Hocko <[email protected]>--- mm/page_alloc.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)mm/page_alloc.c +1
-2@@ -3212,8 +3212,20 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,*/ if (__zone_watermark_ok (zone, order,min_wmark_pages (zone), ac->high_zoneidx, alloc_flags, target)) { -/* Wait for some write requests to complete then retry */ -wait_iff_congested (zone,BLK_RW_ASYNC ,HZ /50 ); + unsigned long writeback = zone_page_state(zone, NR_WRITEBACK),
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3225
Quoted 10 lines
mm/page_alloc.c +10
-0+ dirty =zone_page_state (zone,NR_FILE_DIRTY ); + +/* +* If we didn't make any progress and have a lot of +* dirty + writeback pages then we should wait for +* an IO to complete to slow down the reclaim and +* prevent from pre mature OOM +*/ +if (!did_some_progress &&2 *(writeback + dirty) > reclaimable) +congestion_wait (BLK_RW_ASYNC ,HZ /10 );
The purpose of the heuristic seems logical, but I'm concerned about the threshold for determining when to wait and when to just resched and retry again.
This triggers for environments without swap when
2 * (NR_WRITEBACK + NR_DIRTY) > (NR_ACTIVE_FILE + NR_INACTIVE_FILE +
NR_ISOLATED_FILE + NR_ISOLATED_ANON)
[ The use of NR_ISOLATED_ANON in swapless is asked about in patch 1. ]
How exactly was this chosen? Why not when the two sides equal each other?
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3231
Quoted 6 lines
mm/page_alloc.c +3
-0+else +cond_resched (); + goto retry; } }
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 2/3] mm: throttle on IO only when there are too many dirty and writeback pages
Quoted 28 lines · David Rientjes
Quoted 16 lines · Michal Hocko
From: Michal Hocko <[email protected]>
wait_iff_congestedhas been used to throttle allocator before it retried another round of direct reclaim to allow the writeback to make some progress and prevent reclaim from looping over dirty/writeback pages without making any progress. We used to docongestion_waitbefore0e093d99763e("writeback: do not sleep on the congestion queue if there are no congested BDIs or if significant congestion is not being encountered in the current zone") but that led to undesirable stalls and sleeping for the full timeout even when the BDI wasn't congested. Hencewait_iff_congestedwas used instead. But it seems that evenwait_iff_congesteddoesn't work as expected. We might have a small file LRU list with all pages dirty/writeback and yet the bdi is not congested so this is just acond_reschedin the end and can end up triggering pre mature OOM.Quoted 9 lines
This patch replaces the unconditional
wait_iff_congestedbycongestion_waitwhich is executed only if we _know_ that the last round of direct reclaim didn't make any progress and dirty+writeback pages are more than a half of the reclaimable pages on the zone which might be usable for our target allocation. This shouldn't reintroduce stalls fixed by0e093d99763ebecausecongestion_waitis called only when we are getting hopeless when sleeping is a better choice than OOM with many pages under IO.
Quoted 1 line
Why HZ/10 instead of HZ/50?
My idea was to give the writeback more time. As we only wait when there is a lot of dirty/writeback data it shouldn't stall pointlessly.
Quoted 31 lines
Quoted 16 lines
Signed-off-by Michal Hocko <[email protected]>--- mm/page_alloc.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)mm/page_alloc.c +1
-2@@ -3212,8 +3212,20 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,*/ if (__zone_watermark_ok (zone, order,min_wmark_pages (zone), ac->high_zoneidx, alloc_flags, target)) { -/* Wait for some write requests to complete then retry */ -wait_iff_congested (zone,BLK_RW_ASYNC ,HZ /50 ); + unsigned long writeback = zone_page_state(zone, NR_WRITEBACK),mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3225
Quoted 10 lines
mm/page_alloc.c +10
-0+ dirty =zone_page_state (zone,NR_FILE_DIRTY ); + +/* +* If we didn't make any progress and have a lot of +* dirty + writeback pages then we should wait for +* an IO to complete to slow down the reclaim and +* prevent from pre mature OOM +*/ +if (!did_some_progress &&2 *(writeback + dirty) > reclaimable) +congestion_wait (BLK_RW_ASYNC ,HZ /10 );The purpose of the heuristic seems logical, but I'm concerned about the threshold for determining when to wait and when to just resched and retry again.
Quoted 8 lines
This triggers for environments without swap when
2 * (
NR_WRITEBACK+NR_DIRTY) > (NR_ACTIVE_FILE+NR_INACTIVE_FILE+
NR_ISOLATED_FILE+NR_ISOLATED_ANON)[ The use of
NR_ISOLATED_ANONin swapless is asked about in patch 1. ]How exactly was this chosen? Why not when the two sides equal each other?
The idea was to stall when the to-be-flushed pages form at least half of the reclaimable memory which sounds like an easy concept to start with. This worked reasonably well in my OOM stress tests but I am opened to suggestions. Ideally this should be a function of the writeback speed and maybe we will get there one day but I would like to start with something simple which works most of the time.
Quoted 7 lines
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3231
Quoted 7 lines
mm/page_alloc.c +3
-0+else +cond_resched (); + goto retry; } }
Thanks
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Michal Hocko
reviewerRFC 3/3 mm: use watermak checks for __GFP_REPEAT high order allocations
In reply to Michal HockoFrom: Michal Hocko <[email protected]>
__alloc_pages_slowpath retries costly allocations until at least order worth of pages were reclaimed or the watermark check for at least one zone would succeed after all reclaiming all pages if the reclaim hasn't made any progress.
The first condition was added by a41f24ea9fd6 ("page allocator: smarter retry of costly-order allocations) and it assumed that lumpy reclaim could have created a page of the sufficient order. Lumpy reclaim, has been removed quite some time ago so the assumption doesn't hold anymore. It would be more appropriate to check the compaction progress instead but this patch simply removes the check and relies solely on the watermark check.
To prevent from too many retries the stall_backoff is not reseted after a reclaim which made progress because we cannot assume it helped high order situation.
--- mm/page_alloc.c | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-)
mm/page_alloc.c +8 -12
@@ -3006,7 +3006,6 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;struct page *page =NULL ;int alloc_flags; -unsigned long pages_reclaimed =0 ;unsigned long did_some_progress;enum migrate_mode migration_mode =MIGRATE_ASYNC ;bool deferred_compaction = false;
@@ -3167,24 +3166,21 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,/* * Do not retry high order allocations unless they are __GFP_REPEAT -* and even then do not retry endlessly unless explicitly told so +* unless explicitly told so. */ - pages_reclaimed += did_some_progress; -if (order >PAGE_ALLOC_COSTLY_ORDER ) { -if (!(gfp_mask & __GFP_NOFAIL) && - (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) - goto noretry; - -if (did_some_progress) - goto retry; - } +if (order >PAGE_ALLOC_COSTLY_ORDER && + !(gfp_mask & (__GFP_REPEAT|__GFP_NOFAIL))) + goto noretry;/* * Be optimistic and consider all pages on reclaimable LRUs as usable * but make sure we converge to OOM if we cannot make any progress after * multiple consecutive failed attempts. +* Costly __GFP_REPEAT allocations might have made a progress but this +* doesn't mean their order will become available due to high fragmentation +* so do not reset the backoff for them */ -if (did_some_progress) +if (did_some_progress && order <=PAGE_ALLOC_COSTLY_ORDER ) stall_backoff =0 ;else stall_backoff =min (stall_backoff+1 ,MAX_STALL_BACKOFF );
Signature · 7 lines
2.6.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 3/3] mm: use watermak checks for __GFP_REPEAT high order allocations
Quoted 45 lines · Michal Hocko
From: Michal Hocko <[email protected]>
__alloc_pages_slowpathretries costly allocations until at least order worth of pages were reclaimed or the watermark check for at least one zone would succeed after all reclaiming all pages if the reclaim hasn't made any progress.The first condition was added by
a41f24ea9fd6("page allocator: smarter retry of costly-order allocations) and it assumed that lumpy reclaim could have created a page of the sufficient order. Lumpy reclaim, has been removed quite some time ago so the assumption doesn't hold anymore. It would be more appropriate to check the compaction progress instead but this patch simply removes the check and relies solely on the watermark check.To prevent from too many retries the
stall_backoffis not reseted after a reclaim which made progress because we cannot assume it helped high order situation.Signed-off-by Michal Hocko <[email protected]>--- mm/page_alloc.c | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-)mm/page_alloc.c +1
-4@@ -3006,7 +3006,6 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;struct page *page =NULL ;int alloc_flags; -unsigned long pages_reclaimed =0 ;unsigned long did_some_progress;enum migrate_mode migration_mode =MIGRATE_ASYNC ;bool deferred_compaction = false;@@ -3167,24 +3166,21 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,/* * Do not retry high order allocations unless they are __GFP_REPEAT -* and even then do not retry endlessly unless explicitly told so +* unless explicitly told so. */ - pages_reclaimed += did_some_progress; -if (order >PAGE_ALLOC_COSTLY_ORDER ) {
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3173
Quoted 10 lines
mm/page_alloc.c +3
-7-if (!(gfp_mask & __GFP_NOFAIL) && - (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) - goto noretry; - -if (did_some_progress) - goto retry; - } +if (order >PAGE_ALLOC_COSTLY_ORDER && + !(gfp_mask & (__GFP_REPEAT|__GFP_NOFAIL))) + goto noretry;
Who is allocating order > PAGE_ALLOC_COSTLY_ORDER with __GFP_REPEAT and would be affected by this change?
Quoted 4 lines
mm/page_alloc.c +0
-0/* * Be optimistic and consider all pages on reclaimable LRUs as usable * but make sure we converge to OOM if we cannot make any progress after
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3186
Quoted 10 lines
mm/page_alloc.c +4
-1* multiple consecutive failed attempts. +* Costly __GFP_REPEAT allocations might have made a progress but this +* doesn't mean their order will become available due to high fragmentation +* so do not reset the backoff for them */ -if (did_some_progress) +if (did_some_progress && order <=PAGE_ALLOC_COSTLY_ORDER ) stall_backoff =0 ;else stall_backoff =min (stall_backoff+1 ,MAX_STALL_BACKOFF );
This makes sense if there are high-order users of __GFP_REPEAT since only using a number of pages reclaimed by itself isn't helpful.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 3/3] mm: use watermak checks for __GFP_REPEAT high order allocations
Quoted 1 line · David Rientjes
On Wed, 18 Nov 2015, Michal Hocko wrote:
[...]
Quoted 14 lines
Quoted 14 lines
mm/page_alloc.c +1
-8@@ -3167,24 +3166,21 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,/* * Do not retry high order allocations unless they are __GFP_REPEAT -* and even then do not retry endlessly unless explicitly told so +* unless explicitly told so. */ - pages_reclaimed += did_some_progress; -if (order >PAGE_ALLOC_COSTLY_ORDER ) { -if (!(gfp_mask & __GFP_NOFAIL) && - (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) - goto noretry; - -if (did_some_progress)
Quoted 8 lines
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3173
Quoted 5 lines
mm/page_alloc.c +3
-2- goto retry; - } +if (order >PAGE_ALLOC_COSTLY_ORDER && + !(gfp_mask & (__GFP_REPEAT|__GFP_NOFAIL))) + goto noretry;Who is allocating order >
PAGE_ALLOC_COSTLY_ORDERwith__GFP_REPEATand would be affected by this change?
E.g. hugetlb pages. I have tested this in my testing scenario 3.
Quoted 17 lines
Quoted 4 lines
mm/page_alloc.c +0
-0/* * Be optimistic and consider all pages on reclaimable LRUs as usable * but make sure we converge to OOM if we cannot make any progress after mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3186
Quoted 10 lines
mm/page_alloc.c +4
-1* multiple consecutive failed attempts. +* Costly __GFP_REPEAT allocations might have made a progress but this +* doesn't mean their order will become available due to high fragmentation +* so do not reset the backoff for them */ -if (did_some_progress) +if (did_some_progress && order <=PAGE_ALLOC_COSTLY_ORDER ) stall_backoff =0 ;else stall_backoff =min (stall_backoff+1 ,MAX_STALL_BACKOFF );This makes sense if there are high-order users of
__GFP_REPEATsince only using a number of pages reclaimed by itself isn't helpful.
Yes, that was my thinking
Thanks!
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 3/3] mm: use watermak checks for __GFP_REPEAT high order allocations
Quoted 23 lines · Michal Hocko
Quoted 14 lines
Quoted 14 lines
mm/page_alloc.c +1
-8@@ -3167,24 +3166,21 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,/* * Do not retry high order allocations unless they are __GFP_REPEAT -* and even then do not retry endlessly unless explicitly told so +* unless explicitly told so. */ - pages_reclaimed += did_some_progress; -if (order >PAGE_ALLOC_COSTLY_ORDER ) { -if (!(gfp_mask & __GFP_NOFAIL) && - (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) - goto noretry; - -if (did_some_progress)Quoted 8 lines
mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3173
Quoted 5 lines
mm/page_alloc.c +3
-2- goto retry; - } +if (order >PAGE_ALLOC_COSTLY_ORDER && + !(gfp_mask & (__GFP_REPEAT|__GFP_NOFAIL))) + goto noretry;Who is allocating order >
PAGE_ALLOC_COSTLY_ORDERwith__GFP_REPEATand would be affected by this change?
Quoted 2 lines
E.g. hugetlb pages. I have tested this in my testing scenario 3.
If that's the only high-order user of __GFP_REPEAT, we might want to consider dropping it. I believe the hugetlb usecase would only be relevant in early init (when __GFP_REPEAT shouldn't logically help) and when returning surplus pages due to hugetlb overcommit. Since hugetlb overcommit is best effort and we already know that the pages_reclaimed >= (1<<order) check is ridiculous for order-9 pages, I think you could just drop hugetlb's usage of __GFP_REPEAT and nobody would notice.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [RFC 3/3] mm: use watermak checks for __GFP_REPEAT high order allocations
Quoted 25 lines · David Rientjes
Quoted 23 lines · Michal Hocko
Quoted 22 lines
Quoted 9 lines
mm/page_alloc.c +1
-3@@ -3167,24 +3166,21 @@ __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,/* * Do not retry high order allocations unless they are __GFP_REPEAT -* and even then do not retry endlessly unless explicitly told so +* unless explicitly told so. */ - pages_reclaimed += did_some_progress; -if (order >PAGE_ALLOC_COSTLY_ORDER ) {mm/page_alloc.c __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order, · line 3173
Quoted 10 lines
mm/page_alloc.c +3
-7-if (!(gfp_mask & __GFP_NOFAIL) && - (!(gfp_mask & __GFP_REPEAT) || pages_reclaimed >= (1 <<order))) - goto noretry; - -if (did_some_progress) - goto retry; - } +if (order >PAGE_ALLOC_COSTLY_ORDER && + !(gfp_mask & (__GFP_REPEAT|__GFP_NOFAIL))) + goto noretry;Who is allocating order >
PAGE_ALLOC_COSTLY_ORDERwith__GFP_REPEATand would be affected by this change?
Quoted 5 lines
Quoted 2 lines
E.g. hugetlb pages. I have tested this in my testing scenario 3.
If that's the only high-order user of
__GFP_REPEAT, we might want to consider dropping it.
There are many others. I have tried to clean this area up quite recently
http://lkml.kernel.org/r/1446740160-29094-1-git-send-email-mhocko%40kernel.org
and managed to drop half of the current usage of __GFP_REPEAT.
Quoted 7 lines
I believe the hugetlb usecase would only be
relevant in early init (when__GFP_REPEATshouldn't logically help) and when returning surplus pages due to hugetlb overcommit. Since hugetlb overcommit is best effort and we already know that thepages_reclaimed>= (1<<order) check is ridiculous for order-9 pages, I think you could just drop hugetlb's usage of__GFP_REPEATand nobody would notice.
Even if that was the case, which I am not sure right now, I believe this is a separate topic. We should still support __GFP_REPEAT in some form.
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 4 lines · Michal Hocko
The above results do seem optimistic but more loads should be tested obviously. I would really appreciate a feedback on the approach I have chosen before I go into more tuning. Is this viable way to go?
Tetsuo, does this latest version work for you too?
Andrew - I'm assuming this will all come through you at some point.
Linus
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>