| Message ID | 20240904100923.290042-1-dev.jain@arm.com (mailing list archive) |
|---|---|
| Headers | show |
| Series | Do not shatter hugezeropage on wp-fault | expand |
Hi Dev, On 04/09/2024 11:09, Dev Jain wrote: > It was observed at [1] and [2] that the current kernel behaviour of > shattering a hugezeropage is inconsistent and suboptimal. For a VMA with > a THP allowable order, when we write-fault on it, the kernel installs a > PMD-mapped THP. On the other hand, if we first get a read fault, we get > a PMD pointing to the hugezeropage; subsequent write will trigger a > write-protection fault, shattering the hugezeropage into one writable > page, and all the other PTEs write-protected. The conclusion being, as > compared to the case of a single write-fault, applications have to suffer > 512 extra page faults if they were to use the VMA as such, plus we get > the overhead of khugepaged trying to replace that area with a THP anyway. > > Instead, replace the hugezeropage with a THP on wp-fault. > > v1->v2: > - Wrap do_huge_zero_wp_pmd_locked() around lock and unlock > - Call thp_fault_alloc() before do_huge_zero_wp_pmd_locked() to avoid > - calling sleeping function from spinlock context > > [1]: https://lore.kernel.org/all/3743d7e1-0b79-4eaf-82d5-d1ca29fe347d@arm.com/ > [2]: https://lore.kernel.org/all/1cfae0c0-96a2-4308-9c62-f7a640520242@arm.com/ > > Dev Jain (2): > mm: Abstract THP allocation > mm: Allocate THP on hugezeropage wp-fault > > include/linux/huge_mm.h | 6 ++ > mm/huge_memory.c | 171 +++++++++++++++++++++++++++++----------- > mm/memory.c | 5 +- > 3 files changed, 136 insertions(+), 46 deletions(-) > What is the base for this? It doesn't apply on top of mm-unstable. Thanks, Ryan
On 9/4/24 17:06, Ryan Roberts wrote: > Hi Dev, > > On 04/09/2024 11:09, Dev Jain wrote: >> It was observed at [1] and [2] that the current kernel behaviour of >> shattering a hugezeropage is inconsistent and suboptimal. For a VMA with >> a THP allowable order, when we write-fault on it, the kernel installs a >> PMD-mapped THP. On the other hand, if we first get a read fault, we get >> a PMD pointing to the hugezeropage; subsequent write will trigger a >> write-protection fault, shattering the hugezeropage into one writable >> page, and all the other PTEs write-protected. The conclusion being, as >> compared to the case of a single write-fault, applications have to suffer >> 512 extra page faults if they were to use the VMA as such, plus we get >> the overhead of khugepaged trying to replace that area with a THP anyway. >> >> Instead, replace the hugezeropage with a THP on wp-fault. >> >> v1->v2: >> - Wrap do_huge_zero_wp_pmd_locked() around lock and unlock >> - Call thp_fault_alloc() before do_huge_zero_wp_pmd_locked() to avoid >> - calling sleeping function from spinlock context >> >> [1]: https://lore.kernel.org/all/3743d7e1-0b79-4eaf-82d5-d1ca29fe347d@arm.com/ >> [2]: https://lore.kernel.org/all/1cfae0c0-96a2-4308-9c62-f7a640520242@arm.com/ >> >> Dev Jain (2): >> mm: Abstract THP allocation >> mm: Allocate THP on hugezeropage wp-fault >> >> include/linux/huge_mm.h | 6 ++ >> mm/huge_memory.c | 171 +++++++++++++++++++++++++++++----------- >> mm/memory.c | 5 +- >> 3 files changed, 136 insertions(+), 46 deletions(-) >> > What is the base for this? It doesn't apply on top of mm-unstable. Sorry, forgot to mention, it applies on v6.11-rc5. > > Thanks, > Ryan >
On 04/09/2024 16:41, Dev Jain wrote: > > On 9/4/24 17:06, Ryan Roberts wrote: >> Hi Dev, >> >> On 04/09/2024 11:09, Dev Jain wrote: >>> It was observed at [1] and [2] that the current kernel behaviour of >>> shattering a hugezeropage is inconsistent and suboptimal. For a VMA with >>> a THP allowable order, when we write-fault on it, the kernel installs a >>> PMD-mapped THP. On the other hand, if we first get a read fault, we get >>> a PMD pointing to the hugezeropage; subsequent write will trigger a >>> write-protection fault, shattering the hugezeropage into one writable >>> page, and all the other PTEs write-protected. The conclusion being, as >>> compared to the case of a single write-fault, applications have to suffer >>> 512 extra page faults if they were to use the VMA as such, plus we get >>> the overhead of khugepaged trying to replace that area with a THP anyway. >>> >>> Instead, replace the hugezeropage with a THP on wp-fault. >>> >>> v1->v2: >>> - Wrap do_huge_zero_wp_pmd_locked() around lock and unlock >>> - Call thp_fault_alloc() before do_huge_zero_wp_pmd_locked() to avoid >>> - calling sleeping function from spinlock context >>> >>> [1]: https://lore.kernel.org/all/3743d7e1-0b79-4eaf-82d5-d1ca29fe347d@arm.com/ >>> [2]: https://lore.kernel.org/all/1cfae0c0-96a2-4308-9c62-f7a640520242@arm.com/ >>> >>> Dev Jain (2): >>> mm: Abstract THP allocation >>> mm: Allocate THP on hugezeropage wp-fault >>> >>> include/linux/huge_mm.h | 6 ++ >>> mm/huge_memory.c | 171 +++++++++++++++++++++++++++++----------- >>> mm/memory.c | 5 +- >>> 3 files changed, 136 insertions(+), 46 deletions(-) >>> >> What is the base for this? It doesn't apply on top of mm-unstable. > > Sorry, forgot to mention, it applies on v6.11-rc5. Thanks, I'll give it a review tomorrow. Although I suspect that Andrew will want it based against mm-unstable once it gets into shape for merging. > >> >> Thanks, >> Ryan >>