lkml.org 
[lkml]   [2018]   [Oct]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH 1/2] mm: thp: relax __GFP_THISNODE for MADV_HUGEPAGE mappings
On Mon, 15 Oct 2018, Andrea Arcangeli wrote:

> > At the risk of beating a dead horse that has already been beaten, what are
> > the plans for this patch when the merge window opens? It would be rather
> > unfortunate for us to start incurring a 14% increase in access latency and
> > 40% increase in fault latency. Would it be possible to test with my
> > patch[*] that does not try reclaim to address the thrashing issue? If
> > that is satisfactory, I don't have a strong preference if it is done with
> > a hardcoded pageblock_order and __GFP_NORETRY check or a new
> > __GFP_COMPACT_ONLY flag.
>
> I don't like the pageblock size hardcoding inside the page
> allocator. __GFP_COMPACT_ONLY is fully runtime equivalent, but it at
> least let the caller choose the behavior, so it looks more flexible.
>

I'm not sure that I understand why the user would ever want to thrash
their zone(s) for allocations of this order. The problem here is
specifically related to an entire pageblock becoming freeable and the
unlikeliness that reclaiming/swapping/thrashing will assist memory
compaction in making that happen. For this reason, I think the
order >= pageblock_order check is reasonable because it depends on the
implementation of memory compaction.

Why do we need another gfp flag for thp allocations when they are made to
be __GFP_NORETRY by default and it is very unlikely that reclaiming once
and then retrying compaction is going to make an entire pageblock free?

I'd like to know (1) how continuous reclaim activity can make entire
pageblocks freeable without thrashing and (2) the metrics that we can use
to determine when it is worthwhile vs harmful. I don't believe (1) is
ever helpful based on the implementation of memory compaction and we lack
(2) since reclaim is not targeted to memory that compaction can use.

> As long as compaction returns COMPACT_SKIPPED it's ok to keep doing
> reclaim and keep doing compaction, as long as compaction succeeds.
>

Compaction will operate on 32 pages at a time and declare success each
time and then pick up where it left off the next time it is called in the
hope that it "succeeds" 512/32=16 times in a row while constantly
reclaiming memory. Even a single slab page in that pageblock will make
all of this work useless. Reclaimed memory not accessible by the freeing
scanner will make its work useless. We lack the ability to determine when
compaction is successful in freeing a full pageblock.

\
 
 \ /
  Last update: 2018-10-22 22:46    [W:0.139 / U:12.244 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site