Re: [PATCH v2 2/4] mm: shmem: control THP support through the kernel command line

[Maíra Canal <mcanal@xxxxxxxxxx>]

Hi Baolin,

On 28/10/24 23:03, Baolin Wang wrote:
> On 2024/10/29 08:13, Maíra Canal wrote:
> > Add a new kernel command line to control the hugepage allocation policy
> > for the internal shmem mount, ``transparent_hugepage_shmem``. The
> > parameter is similar to ``transparent_hugepage`` and has the following
> > format:
> >
> > transparent_hugepage_shmem=<policy>
> >
> > where ``<policy>`` is one of the seven valid policies available for
> > shmem.
> >
> > By configuring the default hugepage allocation policy for the internal
> > shmem mount, applications that use shmem, such as the DRM GEM objects,
> > can take advantage of mTHP before it's been configured through sysfs.
>
> Just out of curiosity, do you have any performance benefit data when 
> using mTHP for DRM GEM objects?

I haven't yet benchmark mTHP with V3D (Raspberry Pi's GPU) and also I
still need to find the ideal combination of huge pages' sizes. But the
idea is to benefit from the Super Pages support that I recently
implemented in V3D [1]. Currently, I'm using a separate tmpfs mountpoint
to implement Super Pages.

I'll apply your refactor suggestion in the next version. Thanks!

[1] 
https://mairacanal.github.io/unleashing-power-enabling-super-pages-on-RPi/

Best Regards,
- Maíra

> > Signed-off-by: Maíra Canal <mcanal@xxxxxxxxxx>
> > ---
> >   .../admin-guide/kernel-parameters.txt         |  7 +++
> >   Documentation/admin-guide/mm/transhuge.rst    |  6 +++
> >   mm/shmem.c                                    | 53 +++++++++++++++----
> >   3 files changed, 57 insertions(+), 9 deletions(-)
> >
> > diff --git a/Documentation/admin-guide/kernel-parameters.txt b/ 
> > Documentation/admin-guide/kernel-parameters.txt
> > index 1666576acc0e..acabb04d0dd4 100644
> > --- a/Documentation/admin-guide/kernel-parameters.txt
> > +++ b/Documentation/admin-guide/kernel-parameters.txt
> > @@ -6926,6 +6926,13 @@
> >               See Documentation/admin-guide/mm/transhuge.rst
> >               for more details.
> > +    transparent_hugepage_shmem= [KNL]
> > +            Format: [always|within_size|advise|never|deny|force]
> > +            Can be used to control the hugepage allocation policy for
> > +            the internal shmem mount.
> > +            See Documentation/admin-guide/mm/transhuge.rst
> > +            for more details.
> > +
> >       trusted.source=    [KEYS]
> >               Format: <string>
> >               This parameter identifies the trust source as a backend
> > diff --git a/Documentation/admin-guide/mm/transhuge.rst b/ 
> > Documentation/admin-guide/mm/transhuge.rst
> > index 745055c3dc09..9b5b02c4d1ab 100644
> > --- a/Documentation/admin-guide/mm/transhuge.rst
> > +++ b/Documentation/admin-guide/mm/transhuge.rst
> > @@ -326,6 +326,12 @@ PMD_ORDER THP policy will be overridden. If the 
> > policy for PMD_ORDER
> >   is not defined within a valid ``thp_anon``, its policy will default to
> >   ``never``.
> > +Similarly to ``transparent_hugepage``, you can control the hugepage
> > +allocation policy for the internal shmem mount by using the kernel 
> > parameter
> > +``transparent_hugepage_shmem=<policy>``, where ``<policy>`` is one of 
> > the
> > +seven valid policies for shmem (``always``, ``within_size``, ``advise``,
> > +``never``, ``deny``, and ``force``).
> > +
> >   Hugepages in tmpfs/shmem
> >   ========================
> > diff --git a/mm/shmem.c b/mm/shmem.c
> > index 44282a296c33..26c1eb1b4b1d 100644
> > --- a/mm/shmem.c
> > +++ b/mm/shmem.c
> > @@ -582,7 +582,6 @@ static bool shmem_huge_global_enabled(struct inode 
> > *inode, pgoff_t index,
> >       }
> >   }
> > -#if defined(CONFIG_SYSFS)
> >   static int shmem_parse_huge(const char *str)
> >   {
> >       if (!strcmp(str, "never"))
> > @@ -599,7 +598,6 @@ static int shmem_parse_huge(const char *str)
> >           return SHMEM_HUGE_FORCE;
> >       return -EINVAL;
> >   }
> > -#endif
> >   #if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
> >   static const char *shmem_format_huge(int huge)
> > @@ -624,6 +622,20 @@ static const char *shmem_format_huge(int huge)
> >   }
> >   #endif
> > +static int shmem_valid_huge(int huge)
> > +{
> > +    if (!has_transparent_hugepage() &&
> > +            huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
> > +        return -EINVAL;
> > +
> > +    /* Do not override huge allocation policy with non-PMD sized mTHP */
> > +    if (huge == SHMEM_HUGE_FORCE &&
> > +        huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> > +        return -EINVAL;
> > +
> > +    return 0;
> > +}
> > +
> >   static unsigned long shmem_unused_huge_shrink(struct shmem_sb_info 
> > *sbinfo,
> >           struct shrink_control *sc, unsigned long nr_to_free)
> >   {
> > @@ -5070,14 +5082,10 @@ static ssize_t shmem_enabled_store(struct 
> > kobject *kobj,
> >       huge = shmem_parse_huge(tmp);
> >       if (huge == -EINVAL)
> >           return -EINVAL;
> > -    if (!has_transparent_hugepage() &&
> > -            huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
> > -        return -EINVAL;
> > -    /* Do not override huge allocation policy with non-PMD sized mTHP */
> > -    if (huge == SHMEM_HUGE_FORCE &&
> > -        huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> > -        return -EINVAL;
> > +    err = shmem_valid_huge(huge);
> > +    if (err)
> > +        return err;
> >       shmem_huge = huge;
> >       if (shmem_huge > SHMEM_HUGE_DENY)
> > @@ -5174,6 +5182,33 @@ struct kobj_attribute thpsize_shmem_enabled_attr =
> >       __ATTR(shmem_enabled, 0644, thpsize_shmem_enabled_show, 
> > thpsize_shmem_enabled_store);
> >   #endif /* CONFIG_TRANSPARENT_HUGEPAGE && CONFIG_SYSFS */
> > +#if defined(CONFIG_TRANSPARENT_HUGEPAGE)
> > +
> > +static int __init setup_transparent_hugepage_shmem(char *str)
> > +{
> > +    int huge, ret = 0;
> > +
> > +    if (!str)
> > +        goto out;
> > +
> > +    huge = shmem_parse_huge(str);
> > +    if (huge == -EINVAL)
> > +        goto out;
>
> Looks better. But shmem_parse_huge() is also a common part, and what I 
> am thinking is below:
>
> diff --git a/mm/shmem.c b/mm/shmem.c
> index f8b8b1ad2631..646d8943950a 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -629,24 +629,39 @@ static unsigned int 
> shmem_huge_global_enabled(struct inode *inode, pgoff_t index
>          }
>   }
>
> -#if defined(CONFIG_SYSFS)
>   static int shmem_parse_huge(const char *str)
>   {
> +       int huge;
> +
> +       if (!str)
> +               return -EINVAL;
> +
>          if (!strcmp(str, "never"))
> -               return SHMEM_HUGE_NEVER;
> -       if (!strcmp(str, "always"))
> -               return SHMEM_HUGE_ALWAYS;
> -       if (!strcmp(str, "within_size"))
> -               return SHMEM_HUGE_WITHIN_SIZE;
> -       if (!strcmp(str, "advise"))
> -               return SHMEM_HUGE_ADVISE;
> -       if (!strcmp(str, "deny"))
> -               return SHMEM_HUGE_DENY;
> -       if (!strcmp(str, "force"))
> -               return SHMEM_HUGE_FORCE;
> -       return -EINVAL;
> +               huge = SHMEM_HUGE_NEVER;
> +       else if (!strcmp(str, "always"))
> +               huge = SHMEM_HUGE_ALWAYS;
> +       else if (!strcmp(str, "within_size"))
> +               huge = SHMEM_HUGE_WITHIN_SIZE;
> +       else if (!strcmp(str, "advise"))
> +               huge = SHMEM_HUGE_ADVISE;
> +       else if (!strcmp(str, "deny"))
> +               huge = SHMEM_HUGE_DENY;
> +       else if (!strcmp(str, "force"))
> +               huge = SHMEM_HUGE_FORCE;
> +       else
> +               return -EINVAL;
> +
> +       if (!has_transparent_hugepage() &&
> +           huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
> +               return -EINVAL;
> +
> +       /* Do not override huge allocation policy with non-PMD sized 
> mTHP */
> +       if (huge == SHMEM_HUGE_FORCE &&
> +           huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> +               return -EINVAL;
> +
> +       return huge;
>   }
> -#endif
>
>   #if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
>   static const char *shmem_format_huge(int huge)
> @@ -5104,16 +5119,8 @@ static ssize_t shmem_enabled_store(struct kobject 
> *kobj,
>                  tmp[count - 1] = '\0';
>
>          huge = shmem_parse_huge(tmp);
> -       if (huge == -EINVAL)
> -               return -EINVAL;
> -       if (!has_transparent_hugepage() &&
> -                       huge != SHMEM_HUGE_NEVER && huge != 
> SHMEM_HUGE_DENY)
> -               return -EINVAL;
> -
> -       /* Do not override huge allocation policy with non-PMD sized 
> mTHP */
> -       if (huge == SHMEM_HUGE_FORCE &&
> -           huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> -               return -EINVAL;
> +       if (huge < 0)
> +               return huge;
>
>          shmem_huge = huge;
>          if (shmem_huge > SHMEM_HUGE_DENY)
> @@ -5210,6 +5217,25 @@ struct kobj_attribute thpsize_shmem_enabled_attr =
>          __ATTR(shmem_enabled, 0644, thpsize_shmem_enabled_show, 
> thpsize_shmem_enabled_store);
>   #endif /* CONFIG_TRANSPARENT_HUGEPAGE && CONFIG_SYSFS */
>
> +#if defined(CONFIG_TRANSPARENT_HUGEPAGE)
> +
> +static int __init setup_transparent_hugepage_shmem(char *str)
> +{
> +       int huge;
> +
> +       huge = shmem_parse_huge(str);
> +       if (huge < 0) {
> +               pr_warn("transparent_hugepage_shmem= cannot parse, 
> ignored\n");
> +               return 0;
> +       }
> +
> +       shmem_huge = huge;
> +       return 1;
> +}
> +__setup("transparent_hugepage_shmem=", setup_transparent_hugepage_shmem);
> +
> +#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
> +
>   #else /* !CONFIG_SHMEM */
>
>   /*