Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18;
Content-Type: text/plain;
        charset=us-ascii
Mime-Version: 1.0 (Mac OS X Mail 14.0 \(3654.0.3.2.26\))
Subject: Re: [RFC PATCH 00/16] 1GB THP support on x86_64
From:   William Kucharski <william.kucharski@oracle.com>
In-Reply-To: <53b360d4-8d16-892b-0f7f-5c4cd95208d8@redhat.com>
Date:   Thu, 10 Sep 2020 04:02:44 -0600
Cc:     Jason Gunthorpe <jgg@ziepe.ca>,
        Matthew Wilcox <willy@infradead.org>, Zi Yan <ziy@nvidia.com>,
        Roman Gushchin <guro@fb.com>,
        "Kirill A. Shutemov" <kirill@shutemov.name>, linux-mm@kvack.org,
        Rik van Riel <riel@surriel.com>,
        "Kirill A . Shutemov" <kirill.shutemov@linux.intel.com>,
        Shakeel Butt <shakeelb@google.com>,
        Yang Shi <yang.shi@linux.alibaba.com>,
        David Nellans <dnellans@nvidia.com>,
        linux-kernel@vger.kernel.org
Content-Transfer-Encoding: quoted-printable
Message-Id: <F8242D9A-AB1C-4652-A0EC-C4F4CC670034@oracle.com>
References: <20200902180628.4052244-1-zi.yan@sent.com>
 <20200903142300.bjq2um5y5nwocvar@box>
 <20200903163020.GG60440@carbon.dhcp.thefacebook.com>
 <8e677ead-206d-08dd-d73e-569bd3803e3b@redhat.com>
 <7E20392E-5ED7-4C22-9555-F3BAABF3CBE9@nvidia.com>
 <20200908142758.GF27537@casper.infradead.org>
 <20200909121117.GD87483@ziepe.ca>
 <20200909123244.GD6583@casper.infradead.org>
 <20200909131449.GF87483@ziepe.ca>
 <53b360d4-8d16-892b-0f7f-5c4cd95208d8@redhat.com>
To:     David Hildenbrand <david@redhat.com>
Sender: linux-kernel-owner@vger.kernel.org
Precedence: bulk


> On Sep 9, 2020, at 7:27 AM, David Hildenbrand <david@redhat.com> =
wrote:
>=20
> On 09.09.20 15:14, Jason Gunthorpe wrote:
>> On Wed, Sep 09, 2020 at 01:32:44PM +0100, Matthew Wilcox wrote:
>>=20
>>> But here's the thing ... we already allow
>>> 	mmap(MAP_POPULATE | MAP_HUGETLB | MAP_HUGE_1GB)
>>>=20
>>> So if we're not doing THP, what's the point of this thread?
>>=20
>> I wondered that too..
>>=20
>>> An madvise flag is a different beast; that's just letting the kernel
>>> know what the app thinks its behaviour will be.  The kernel can pay
>>=20
>> But madvise is too late, the VMA already has an address, if it is not
>> 1G aligned it cannot be 1G THP already.
>=20
> That's why user space (like QEMU) is THP-aware and selects an address
> that is aligned to the expected THP granularity (e.g., 2MB on x86_64).


To me it's always seemed like there are two major divisions among THP =
use
cases:

1) Applications that KNOW they would benefit from use of THPs, so they
call madvise() with an appropriate parameter and explicitly inform the
kernel of such

2) Applications that know nothing about THP but there may be an
advantage that comes from "automatic" THP mapping when possible.

This is an approach that I am more familiar with that comes down to:

    1) Is a VMA properly aligned for a (whatever size) THP?

    2) Is the mapping request for a length >=3D (whatever size) THP?

    3) Let's try allocating memory to map the space using (whatever =
size)
       THP, and:

        -- If we succeed, great, awesome, let's do it.
        -- If not, no big deal, map using as large a page as we CAN get.

There of course are myriad performance implications to this. Processes
that start early after boot have a better chance of getting a THP,
but that also means frequently mapped large memory spaces have a better
chance of being mapped in a shared manner via a THP, e.g. libc, X =
servers
or Firefox/Chrome. It also means that processes that would be mapped
using THPs early in boot may not be if they should crash and need to be
restarted.

There are all sorts of tunables that would likely need to be in place to =
make
the second approach more viable, but I think it's certainly worth =
investigating.

The address selection you suggest is the basis of one of the patches I =
wrote
for a previous iteration of THP support (and that is in Matthew's THP =
tree)
that will try to round VM addresses to the proper alignment if possible =
so a
THP can then be used to map the area.