Configure o recurso de reclaim de THP para resolver o problema de inchaço de memória causado por THPs - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

O reclaim de THP divide as Transparent Huge Pages (THPs) em subpáginas e recupera subpáginas zeradas para evitar erros de falta de memória (OOM) causados por inchaço de memória. Este tópico descreve as interfaces para configurar o reclaim de THP em grupos de controle de memória, além de como ativar e testar o recurso.

Contexto

O Linux gerencia a memória em páginas. As páginas regulares têm 4 KiB. As THPs são blocos maiores — de 2 MiB ou 1 GiB — que o kernel aloca dinamicamente para reduzir falhas no Translation Lookaside Buffer (TLB) e melhorar o desempenho das aplicações.

As THPs podem causar inchaço de memória. Quando uma aplicação solicita apenas 8 KiB, o kernel pode alocar uma THP de 2 MiB. Essa THP contém as duas páginas de 4 KiB solicitadas mais 510 páginas de 4 KiB preenchidas com zeros (páginas zeradas), desperdiçando o tamanho do conjunto residente (RSS) e aumentando o risco de OOM.

O reclaim de THP resolve esse problema dividindo as THPs em subpáginas e recuperando as subpáginas zeradas. Observe que ativar o reclaim de THP pode degradar o desempenho da memória.

Interfaces

As interfaces a seguir controlam o comportamento do reclaim de THP.

Interface	Descrição
`memory.thp_reclaim`	Ativa ou desativa o reclaim de THP para um grupo de controle de memória. Valores válidos: `reclaim` (ativar), `swap` (reservado para uso futuro), `disable` (padrão). Ative `reclaim` quando o inchaço de memória estiver causando erros OOM; note que isso pode degradar o desempenho da memória.
`memory.thp_reclaim_stat`	Consulta o status do reclaim de THP para um grupo de controle de memória. Relata três contadores por nó NUMA, listados em ordem crescente de ID do nó NUMA (node0, node1, ...): `queue_length` (THPs atualmente na fila de reclaim), `split_hugepage` (total de THPs divididas), `reclaim_subpage` (total de subpáginas zeradas recuperadas).
`memory.thp_reclaim_ctrl`	Controla como o reclaim de THP é acionado. Parâmetros: `threshold` (número máximo de subpáginas zeradas em uma THP antes do acionamento do reclaim; padrão: `16`), `reclaim` (somente escrita; aciona o reclaim imediatamente). Ajuste `threshold` para controlar o que qualifica uma THP com excesso de zeros — valores menores acionam o reclaim de forma mais agressiva; valores maiores reduzem a frequência de reclaim.
`/sys/kernel/mm/transparent_hugepage/reclaim`	Interface global que substitui as configurações por cgroup. Valores válidos: `memcg` (cada cgroup usa sua própria configuração `memory.thp_reclaim`; padrão), `reclaim` (força a ativação do reclaim para todos os cgroups), `swap` (reservado para uso futuro), `disable` (força a desativação do reclaim para todos os cgroups). Quando definido como `reclaim` ou `disable`, esta interface tem precedência sobre as configurações `memory.thp_reclaim` por cgroup. As configurações por cgroup são preservadas e voltam a ter efeito se a interface global for redefinida para `memcg`.

Versões de kernel compatíveis

O reclaim de THP é compatível com as seguintes versões de kernel do Alibaba Cloud Linux:

Alibaba Cloud Linux 2: kernel 4.19.91-24.al7 ou posterior
Alibaba Cloud Linux 3: kernel 5.10.134-15.al8 ou posterior

Para verificar a versão do seu kernel, execute:

uname -r

Configure o reclaim de THP

Os passos abaixo configuram o reclaim de THP para um grupo de controle de memória chamado test.

Pré-requisitos

Antes de começar, certifique-se de que:

Sua versão de kernel atende aos requisitos mínimos listados em Versões de kernel compatíveis
Você possui privilégios sudo na instância

Procedimento

Crie um grupo de controle de memória chamado test:
```
sudo mkdir /sys/fs/cgroup/memory/test/
```

Ative o reclaim de THP para test:

sudo sh -c 'echo reclaim > /sys/fs/cgroup/memory/test/memory.thp_reclaim'

Verifique se o reclaim de THP está ativado:
```
cat /sys/fs/cgroup/memory/test/memory.thp_reclaim
```
A configuração ativa aparece entre colchetes. A saída a seguir confirma que o reclaim de THP está ativado:
```
[reclaim] swap disable
```
(Opcional) Substitua as configurações por cgroup usando a interface global.

Para forçar a ativação do reclaim de THP em todos os grupos de controle de memória:
```
sudo sh -c 'echo reclaim > /sys/kernel/mm/transparent_hugepage/reclaim'
```
Para forçar a desativação do reclaim de THP em todos os grupos de controle de memória:
```
sudo sh -c 'echo disable > /sys/kernel/mm/transparent_hugepage/reclaim'
```
Nota: Quando a interface global está definida como reclaim ou disable , ela tem precedência sobre a interface memory.thp_reclaim . As configurações memory.thp_reclaim por cgroup não são afetadas.
Defina o limiar de subpáginas zeradas para test.

O parâmetro threshold define o número máximo de subpáginas zeradas que uma THP pode conter antes de acionar o reclaim de THP. O padrão é 16. Para alterá-lo para 32:
```
sudo sh -c 'echo "threshold 32" > /sys/fs/cgroup/memory/test/memory.thp_reclaim_ctrl'
```
Com essa configuração, o reclaim de THP é acionado quando uma THP contém mais de 32 subpáginas zeradas.
Acione manualmente o reclaim de subpáginas zeradas.

Nota: O parâmetro reclaim em memory.thp_reclaim_ctrl é somente de escrita. Executar cat nesta interface não retorna a configuração reclaim .

Para acionar o reclaim apenas para test:
```
sudo sh -c 'echo "reclaim 1" > /sys/fs/cgroup/memory/test/memory.thp_reclaim_ctrl'
```
Para acionar o reclaim recursivamente para test e todos os seus grupos de controle filhos:
```
sudo sh -c 'echo "reclaim 2" > /sys/fs/cgroup/memory/test/memory.thp_reclaim_ctrl'
```
O reclaim de THP também é acionado automaticamente quando:
- Ocorre um erro OOM no cgroup.
- O recurso de reclaim assíncrono de backend memcg é acionado. Para obter detalhes, consulte Reclaim assíncrono de backend Memcg.
Verifique o status do reclaim de THP para test:
```
cat /sys/fs/cgroup/memory/test/memory.thp_reclaim_stat
```
Exemplo de saída:
```
queue_length        14
split_hugepage     523
reclaim_subpage 256207
```
- queue_length 14: 14 THPs estão atualmente na fila de reclaim.
- split_hugepage 523: 523 THPs foram divididas.
- reclaim_subpage 256207: 256.207 subpáginas zeradas foram recuperadas.

Testar o recurso de reclaim de THP

O código C de exemplo abaixo aloca 1 GiB de memória (512 THPs), onde 10 THPs contêm subpáginas zeradas. Use-o para comparar o comportamento da memória com o reclaim de THP ativado e desativado.

Defina o limite de memória para test como 1 GiB:

sudo sh -c 'echo 1G > /sys/fs/cgroup/memory/test/memory.limit_in_bytes'

Verifique o valor:

cat /sys/fs/cgroup/memory/test/memory.limit_in_bytes

A saída esperada é:

1073741824

Desative o recurso de reclaim assíncrono de backend memcg para isolar o teste:
```
sudo sh -c 'echo 0 > /sys/fs/cgroup/memory/test/memory.wmark_ratio'
```
Para obter detalhes sobre este recurso, consulte Reclaim assíncrono de backend Memcg.
Compile e execute o código C de exemplo com o reclaim de THP ativado e depois desativado. Compare os resultados.

Compilação:
```
gcc -o test <test.c>
```
Substitua <test.c> pelo nome real do seu arquivo source.
```
// Allocates 1 GiB (512 THPs). The first 10 THPs contain zero subpages.
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define HUGEPAGE_SIZE 4096 * 512

int main()
{
    int i, thp = 512;
    char *addr;
    posix_memalign((void **)&addr, HUGEPAGE_SIZE, HUGEPAGE_SIZE * thp);

    for (i = 0; i < 10; i++) {
        memset(addr, 0xc, HUGEPAGE_SIZE >> 1);
        addr += HUGEPAGE_SIZE;
    }

    for (; i < thp; i++) {
        memset(addr, 0xc, HUGEPAGE_SIZE);
        addr += HUGEPAGE_SIZE;
    }

    pause();
    return 0;
}
```
Em um terminal separado, monitore erros OOM:
```
dmesg -wH
```
Resultados esperados:
- Reclaim de THP ativado: O recurso divide as THPs alocadas e recupera subpáginas zeradas, reduzindo o uso de memória e evitando erros OOM.
- Reclaim de THP desativado: As THPs não são divididas e as subpáginas zeradas não são recuperadas. Podem ocorrer erros OOM. Os logs do kernel mostram memória insuficiente e os detalhes dos processos que podem ser encerrados.

Alibaba Cloud Linux:Reclaim de THP