Re: [PATCH 0/15] mm: introduce ANON_VMA_LAZY for deferred anon_vma creation

["David Hildenbrand (Arm)" <david@kernel.org>]

On 5/27/26 13:01, tao wrote:
> TL;DR
> -----
> 
> This series introduces ANON_VMA_LAZY, which defers anon_vma creation
> until it is actually required.
> 
> - anon_vma memory reduced by ~92-97%, anon_vma_chain reduced by ~50-57%  
> - rmap operations on ANON_VMA_LAZY VMAs do not require anon_vma locking
> 
> Background
> ----------
> 
> Currently anon_vma structures are created eagerly when anonymous VMAs
> are initialized. However, many VMAs never participate in fork or rmap
> operations that require anon_vma chains, so the allocated anon_vma and
> anon_vma_chain objects are often unnecessary.
> 
> Design overview
> ---------------
> 
> ANON_VMA_LAZY defers anon_vma allocation until it is actually needed
> (for example during fork). VMAs that never participate in sharing can
> avoid creating anon_vma structures entirely.
> 
> Before an anon_vma exists, rmap operations rely directly on VMA
> information, so no anon_vma locking is required. An anon_vma is created
> and linked only when sharing semantics are required.
> 
> This series introduces anon_rmap helpers to make rmap less dependent on
> direct anon_vma access. It also introduces anon_vma_tree_t as a container
> to support both the lazy and the existing anon_vma layouts.
> 
> Once a VMA becomes associated with an anon_vma, the normal behavior
> remains unchanged.
> 
> Memory impact
> -------------
> 
> Preliminary measurements show significant reductions in anon_vma-related
> slab allocations.
> 
> After boot:
> 
> Object            | Before (active KB) | After (active KB) | Change
> vm_area_struct    | 117035             | 118176            | +1.0%
> anon_vma_chain    | 18865.8            | 8112.06           | -57.0%
> anon_vma          | 20426.4            | 613.75            | -97.0%
> 
> After launching 24 apps:
> 
> Object            | Before (active KB) | After (active KB) | Change
> vm_area_struct    | 196873             | 197345            | +0.2%
> anon_vma_chain    | 31477.1            | 15576.8           | -50.5%
> anon_vma          | 33280              | 2648.12           | -92.0%
> 
> Simple fork microbenchmarks also show a slight improvement in fork
> performance, since child VMAs do not need to allocate anon_vma
> structures during fork.
> 
> Feedback and suggestions are welcome.
> 
> 
> tao (15):
>   mm/rmap: introduce anon_rmap APIs for anonymous folios
>   mm: convert anon_vma rmap APIs to anon_rmap
>   mm: introduce anon_vma_tree_t for multiple anon_vma topologies
>   mm: switch to anon_vma_tree_t APIs in preparation for ANON_VMA_LAZY
>   mm: add CONFIG_ANON_VMA_LAZY and folio helpers
>   mm: add CONFIG_VMA_REF and VMA helpers
>   mm: replace direct FOLIO_MAPPING_ANON usage with helpers
>   mm: prepare rmap infrastructure for ANON_VMA_LAZY
>   mm: implement ANON_VMA_LAZY rmap semantics
>   mm: defer anon_vma creation with ANON_VMA_LAZY
>   mm: handle ANON_VMA_LAZY in huge page operations
>   mm: handle ANON_VMA_LAZY during migration
>   mm: support setup and upgrade of ANON_VMA_LAZY folios
>   mm: support merging of ANON_VMA_LAZY VMAs
>   mm: enable CONFIG_ANON_VMA_LAZY on arm64 and x86_64
> 
>  arch/arm64/Kconfig         |   1 +
>  arch/x86/Kconfig           |   1 +
>  fs/proc/page.c             |   6 +-
>  include/linux/mm.h         |  38 ++
>  include/linux/mm_types.h   |   9 +-
>  include/linux/page-flags.h |  34 +-
>  include/linux/pagemap.h    |   2 +-
>  include/linux/rmap.h       | 165 ++++++++-
>  mm/Kconfig                 |  22 ++
>  mm/damon/ops-common.c      |   4 +-
>  mm/debug.c                 |   2 +-
>  mm/debug_vm_pgtable.c      |   2 +-
>  mm/gup.c                   |   6 +-
>  mm/huge_memory.c           |  16 +-
>  mm/internal.h              | 171 +++++++++
>  mm/khugepaged.c            |  13 +-
>  mm/ksm.c                   |  43 ++-
>  mm/memory-failure.c        |  11 +-
>  mm/memory.c                |  19 +-
>  mm/migrate.c               | 126 ++++---
>  mm/mmap.c                  |  15 +-
>  mm/mremap.c                |   4 +-
>  mm/page_idle.c             |   2 +-
>  mm/rmap.c                  | 690 ++++++++++++++++++++++++++++++++++---
>  mm/vma.c                   |  76 ++--
>  mm/vma.h                   |   4 +-
>  mm/vma_exec.c              |   2 +-
>  mm/vma_init.c              |   1 +
>  28 files changed, 1279 insertions(+), 206 deletions(-)

Hi!

When I saw the diffsat I was concerned. Going through the patches made me ...
more concerned :)

This is a lot of complexity. On top of something that is already so complicated
that I fail to grasp most details without regularly taking a look at the nice
figures Lorenzo created recently.

For example, I read above "since child VMAs do not need to allocate anon_vma"
and wondered how that could be part of something that is just done lazily. Then
I had to learn in the patches that there is some additional "Child VMAs
are created as ANON_VMA_TREE_PARENT and do not allocate anon_vma" -- excuse me,
what? :)

Reading about VMA refcounts made me shiver. Reading "Holding only
folio_lock(folio) cannot guarantee that the split
operation completes atomically." confused me. Learning that we have to invent
interesting ways to make page migration mutually exclusive to free_pgtables()
concerned me. Figuring out that there are arch-specific config options and
runtime toggles is a clear warning sign.

Seeing test_folio_unmapped() was funny, though (why?! :)).

I think this patch set has a noble goal of reducing anon_vma overhead when anon
pages are not shared during fork. However, using anon_vma for them actually
makes the overall implementation (e.g., rmap walks, locking) more consistent and
simpler.

Even if we could be convinced that most of this here is correct, how should we
reasonably maintain this increasing level of complexity here?

I won't echo what has already been said in this thread (and I didn't manage to
read all, unfortunately), but for such big and invasive work it's often best to
get in touch with the community earlier. Otherwise, you might end up wasting
your time.

Ok, arguably, someone who writes that code learns a lot on the way. And if this
code really was written by one developer only, I tip my hat! I'd be curious if
that code already ran somewhere on some Android kernel out there?

But adding more complexity on top of something that's already extremely
complicated to save some memory looks like the wrong direction, really.

I was excited when Lorenzo started working on a completely new approach that
would focus on improving the common cases while trying to reduce the overall
complexity. Because I think most of us really dislike anon_vma. It's still work
in progress, and I am sure there are some rough edges.

But fundamentally, I think we want to find a new design that is just naturally
simpler.

Lorenzo has been hard at work exploring various design options (and I'm afraid
he might be one of the 3 people on this planet that understand anon_vma in full
detail), so I suggest we wait for a redesign proposal from him and see if that
is doable?

-- 
Cheers,

David