MIME-Version: 1.0
References: <20211220085649.8196-1-songmuchun@bytedance.com>
 <20211220085649.8196-2-songmuchun@bytedance.com> <YdeDym9IUghnagrK@carbon.dhcp.thefacebook.com>
 <CAMZfGtV2G=R9nTuSYGAeqv+RkJsCVVACc3h47OeWA7n3mWbqsA@mail.gmail.com> <Ydx+BWQp18hjdO32@carbon.dhcp.thefacebook.com>
In-Reply-To: <Ydx+BWQp18hjdO32@carbon.dhcp.thefacebook.com>
From:   Muchun Song <songmuchun@bytedance.com>
Date:   Tue, 11 Jan 2022 11:19:04 +0800
Message-ID: <CAMZfGtVDjtG2D3Ri4WROD5F1cSeA+V+t1W+TXmOQzJoJdPg+kQ@mail.gmail.com>
Subject: Re: [PATCH v5 01/16] mm: list_lru: optimize memory consumption of
 arrays of per cgroup lists
To:     Roman Gushchin <guro@fb.com>
Cc:     Matthew Wilcox <willy@infradead.org>,
        Andrew Morton <akpm@linux-foundation.org>,
        Johannes Weiner <hannes@cmpxchg.org>,
        Michal Hocko <mhocko@kernel.org>,
        Vladimir Davydov <vdavydov.dev@gmail.com>,
        Shakeel Butt <shakeelb@google.com>,
        Yang Shi <shy828301@gmail.com>, Alex Shi <alexs@kernel.org>,
        Wei Yang <richard.weiyang@gmail.com>,
        Dave Chinner <david@fromorbit.com>,
        trond.myklebust@hammerspace.com, anna.schumaker@netapp.com,
        jaegeuk@kernel.org, chao@kernel.org,
        Kari Argillander <kari.argillander@gmail.com>,
        linux-fsdevel <linux-fsdevel@vger.kernel.org>,
        LKML <linux-kernel@vger.kernel.org>,
        Linux Memory Management List <linux-mm@kvack.org>,
        linux-nfs@vger.kernel.org, Qi Zheng <zhengqi.arch@bytedance.com>,
        Xiongchun duan <duanxiongchun@bytedance.com>,
        Fam Zheng <fam.zheng@bytedance.com>,
        Muchun Song <smuchun@gmail.com>
Content-Type: text/plain; charset="UTF-8"
Precedence: bulk

On Tue, Jan 11, 2022 at 2:42 AM Roman Gushchin <guro@fb.com> wrote:
>
> On Sun, Jan 09, 2022 at 12:49:56PM +0800, Muchun Song wrote:
> > On Fri, Jan 7, 2022 at 8:05 AM Roman Gushchin <guro@fb.com> wrote:
> > >
> > > On Mon, Dec 20, 2021 at 04:56:34PM +0800, Muchun Song wrote:
> > > > The list_lru uses an array (list_lru_memcg->lru) to store pointers
> > > > which point to the list_lru_one. And the array is per memcg per node.
> > > > Therefore, the size of the arrays will be 10K * number_of_node * 8 (
> > > > a pointer size on 64 bits system) when we run 10k containers in the
> > > > system. The memory consumption of the arrays becomes significant. The
> > > > more numa node, the more memory it consumes.
> > > >
> > > > I have done a simple test, which creates 10K memcg and mount point
> > > > each in a two-node system. The memory consumption of the list_lru
> > > > will be 24464MB. After converting the array from per memcg per node
> > > > to per memcg, the memory consumption is going to be 21957MB. It is
> > > > reduces by 2.5GB. In our AMD servers with 8 numa nodes in those
> > > > sysuem, the memory consumption could be more significant. The savings
> > > > come from the list_lru_one heads, that it also simplifies the
> > > > alloc/dealloc path.
> > > >
> > > > The new scheme looks like the following.
> > > >
> > > >   +----------+   mlrus   +----------------+   mlru   +----------------------+
> > > >   | list_lru +---------->| list_lru_memcg +--------->|  list_lru_per_memcg  |
> > > >   +----------+           +----------------+          +----------------------+
> > > >                                                      |  list_lru_per_memcg  |
> > > >                                                      +----------------------+
> > > >                                                      |          ...         |
> > > >                           +--------------+   node    +----------------------+
> > > >                           | list_lru_one |<----------+  list_lru_per_memcg  |
> > > >                           +--------------+           +----------------------+
> > > >                           | list_lru_one |
> > > >                           +--------------+
> > > >                           |      ...     |
> > > >                           +--------------+
> > > >                           | list_lru_one |
> > > >                           +--------------+
> > > >
> > > > Signed-off-by: Muchun Song <songmuchun@bytedance.com>
> > > > Acked-by: Johannes Weiner <hannes@cmpxchg.org>
> > >
> > > As much as I like the code changes (there is indeed a significant simplification!),
> > > I don't like the commit message and title, because I wasn't able to understand
> > > what the patch is doing and some parts look simply questionable. Overall it
> > > sounds like you reduce the number of list_lru_one structures, which is not true.
> > >
> > > How about something like this?
> > >
> > > --
> > > mm: list_lru: transpose the array of per-node per-memcg lru lists
> > >
> > > The current scheme of maintaining per-node per-memcg lru lists looks like:
> > >   struct list_lru {
> > >     struct list_lru_node *node;           (for each node)
> > >       struct list_lru_memcg *memcg_lrus;
> > >         struct list_lru_one *lru[];       (for each memcg)
> > >   }
> > >
> > > By effectively transposing the two-dimension array of list_lru_one's structures
> > > (per-node per-memcg => per-memcg per-node) it's possible to save some memory
> > > and simplify alloc/dealloc paths. The new scheme looks like:
> > >   struct list_lru {
> > >     struct list_lru_memcg *mlrus;
> > >       struct list_lru_per_memcg *mlru[];  (for each memcg)
> > >         struct list_lru_one node[0];      (for each node)
> > >   }
> > >
> > > Memory savings are coming from having fewer list_lru_memcg structures, which
> > > contain an extra struct rcu_head to handle the destruction process.
> >
> > My bad English. Actually, the saving is coming from not only 'struct rcu_head'
> > but also some pointer arrays used to store the pointer to 'struct list_lru_one'.
> > The array is per node and its size is 8 (a pointer) * num_memcgs.
>
> Nice! Please, add this to the commit log.

Will do.

>
> > So the total
> > size of the arrays is  8 * num_nodes * memcg_nr_cache_ids. After this patch,
> > the size becomes 8 * memcg_nr_cache_ids. So the saving is
> >
> >    8 * (num_nodes - 1) * memcg_nr_cache_ids.
> >
> > > --
> > >
> > > But what worries me is that memory savings numbers you posted don't do up.
> > > In theory we can save
> > > 16 (size of struct rcu_head) * 10000 (number of cgroups) * 2 (number of numa nodes) = 320k
> > > per slab cache. Did you have a ton of mount points? Otherwise I don't understand
> > > where these 2.5Gb are coming from.
> >
> > memcg_nr_cache_ids is 12286 when creating 10k memcgs. So the saving
> > of arrays of one list_lru is 8 * 1 (number of numa nodes - 1) * 12286 = 96k.
> > There will be 2 * 10k list_lru when mounting 10k points. So the total
> > saving is 96k * 2 * 10k = 1920 M.
>
> So, there are 10k cgroups _and_ 10k mountpoints. Please, make it obvious from
> the commit log. Most users don't have that many mount points (and likely cgroups),
> so they shouldn't expect Gb's in savings.

I'll add those infos into the commit log.

>
> Thanks!
>
> PS I hope to review the rest of the patchset till the end of this week.

Thanks Roman.