how to improve the system performance of Alibaba Cloud Linux by using Hugetext - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

O Hugetext é uma extensão do Transparent Huge Pages (THP) que mapeia as seções executáveis de aplicações e bibliotecas de vínculo dinâmico (DLLs) para huge pages (geralmente de 2 MB). Ao reduzir as falhas no instruction Translation Lookaside Buffer (iTLB) e aumentar a utilização do iTLB, o Hugetext melhora o desempenho de workloads com grandes segmentos de código, como os bancos de dados MySQL e PostgreSQL e aplicações Java de grande escala. Esse recurso também ajuda a evitar fragmentação e inflação de memória, otimizando o uso geral da memória.

Os ganhos de desempenho variam conforme a plataforma e o workload. O impacto do Hugetext é maior quando a pressão sobre o iTLB representa um gargalo.

Pré-requisitos

Antes de começar, verifique se você tem:

Uma instância Alibaba Cloud Linux executando uma das seguintes versões de kernel:
- Alibaba Cloud Linux 2: kernel 4.19.91-25 ou posterior
- Alibaba Cloud Linux 3: kernel 5.10.112-11 ou posterior

Execute uname -r para verificar a versão do kernel na sua instância.

Funcionamento

O Hugetext funciona de maneira semelhante ao THP, mas atua apenas em segmentos de código, e não em toda a memória anônima. Quando ativado, o kernel verifica assincronamente os mapeamentos de memória executável (arquivos binários e DLLs) e consolida as páginas elegíveis em huge pages de 2 MB. Essa abordagem reduz o número de entradas necessárias no iTLB, diminui a taxa de falhas e aumenta a eficiência da CPU durante todo o ciclo de vida da aplicação.

Como o Hugetext opera de forma assíncrona, as páginas não são mescladas imediatamente após a ativação do recurso nem divididas instantaneamente após a desativação.

Ativar o Hugetext

O Hugetext vem desativado por padrão. Para ativá-lo, use a interface sysfs gravando um dos valores abaixo em /sys/kernel/mm/transparent_hugepage/hugetext_enabled.

Valor	Modo	Descrição
`1`	Páginas binárias e de bibliotecas dinâmicas	Mapeia seções executáveis de arquivos binários e DLLs para huge pages. Recomendado para a maioria dos workloads de bancos de dados e aplicações.
`2`	Páginas executáveis anônimas	Mapeia páginas executáveis anônimas (código compilado JIT) para huge pages. Ideal para Java ou outros runtimes baseados em JIT.
`3`	Todos os anteriores	Combina os modos 1 e 2. Use esta opção quando seu workload incluir tanto binários estáticos quanto código compilado via JIT.

Execute o comando correspondente ao modo desejado:

Modo 1 — Páginas binárias e de bibliotecas dinâmicas:

sudo sh -c 'echo 1 > /sys/kernel/mm/transparent_hugepage/hugetext_enabled'

Modo 2 — Páginas executáveis anônimas:

sudo sh -c 'echo 2 > /sys/kernel/mm/transparent_hugepage/hugetext_enabled'

Modo 3 — Páginas binárias, de bibliotecas dinâmicas e executáveis anônimas:
```
sudo sh -c 'echo 3 > /sys/kernel/mm/transparent_hugepage/hugetext_enabled'
```

Configurar o Hugetext na inicialização

Para manter a configuração do Hugetext após reinicializações, defina o parâmetro de boot hugetext na configuração do GRand Unified Bootloader (GRUB). Esse parâmetro aceita os mesmos valores (0, 1, 2 ou 3) descritos na tabela acima. Consulte a documentação da sua versão do GRUB e da imagem utilizada para obter a sintaxe exata.

Verificar se o Hugetext está ativo

Após ativar o Hugetext, aguarde o tempo necessário para que o kernel consolide as páginas de forma assíncrona. Em seguida, verifique o campo FilePmdMapped em /proc/<pid>/smaps, que informa o tamanho das huge pages mapeadas para um processo (em KB).

Substitua <pid> pelo ID real do processo. Para descobrir o ID de um serviço em execução, use o comando pidof. Exemplo: pidof sshd.

sudo cat /proc/<pid>/smaps | grep FilePmdMapped | awk '{sum+=$2}END{print"Sum= ",sum}'

Um valor de Sum maior que 0 confirma que o processo está utilizando huge pages. Se o valor for 0, o kernel ainda não consolidou as páginas para esse processo ou ele não possui segmentos de código elegíveis.

Desativar o Hugetext

sudo sh -c 'echo 0 > /sys/kernel/mm/transparent_hugepage/hugetext_enabled'

Após a desativação, o kernel não divide imediatamente as huge pages existentes, e os caches dessas páginas também permanecem. Para limpá-los, adote um dos métodos a seguir.

Limpar caches de huge pages

Execute um destes comandos antes de realizar benchmarks para garantir que os resultados dos testes não sejam distorcidos por huge pages armazenadas em cache de uma sessão anterior.

Limpe o cache de páginas de todo o sistema:

sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches'

Remova o cache de páginas de um arquivo específico:
```
sudo vmtouch -e /<path>/target
```
Substitua <path> pelo diretório do binário da sua aplicação. É necessário ter o Virtual Memory Toucher (vmtouch) instalado. Caso contrário, execute:
```
sudo yum install vmtouch
```

Divida as huge pages residuais:

sudo sh -c 'echo 1 > /sys/kernel/debug/split_huge_pages'

Ativar preenchimento (padding)

O preenchimento é uma otimização opcional para casos em que o segmento de texto de um binário é menor que 2 MB e, portanto, não consegue usar uma huge page isoladamente. Quando o tamanho do segmento de texto ultrapassa o valor definido em hugetext_pad_threshold, o kernel preenche o segmento até atingir 2 MB, permitindo seu mapeamento para uma huge page.

Essa funcionalidade exige que o Hugetext esteja ativado.

Ative o preenchimento definindo hugetext_pad_threshold (intervalo válido: 0–2097151):

sudo sh -c 'echo [0~2097151] > /sys/kernel/mm/transparent_hugepage/hugetext_pad_threshold'

Na maioria dos cenários, o valor 4096 apresenta bons resultados:

sudo sh -c 'echo 4096 > /sys/kernel/mm/transparent_hugepage/hugetext_pad_threshold'

Para desativar o preenchimento:

sudo sh -c 'echo 0 > /sys/kernel/mm/transparent_hugepage/hugetext_pad_threshold'

Nota sobre alinhamento: Para que o preenchimento funcione corretamente, os segmentos de código e dados devem estar alinhados a 2 MB. Para fazer esse ajuste, modifique o script de vinculador padrão (arquivo IDS) e adicione . = ALIGN(0x200000); antes de cada segmento de código ou dados. Sem o alinhamento de 2 MB, o conteúdo após os segmentos rw-p ou r--p pode não receber o preenchimento esperado, fazendo com que algumas seções revertam para páginas de 4 KB.

Benefícios de desempenho

Em máquinas físicas, o Hugetext geralmente aumenta o desempenho das aplicações entre 5% e 8%. Máquinas virtuais costumam apresentar ganhos ainda maiores, pois o alívio na pressão do TLB é mais expressivo em ambientes virtualizados.

Os resultados a seguir foram obtidos em um benchmark do MySQL executado em uma plataforma ARM com uma instância de 32 vCPUs.

Transações por segundo (TPS): huge pages de 2 MB vs. páginas padrão de 4 KB

TPS data

Concorrência	Ganho de desempenho
1 conexão	TPS aproximadamente 6,9% maior com huge pages
8–16 conexões (contenção de CPU eliminada, ~25%–50% de utilização)	Aumento superior a 6,5% no TPS
32 conexões (CPU em 100%, workloads concorrentes)	TPS cerca de 11% maior; huge pages também proporcionam maior estabilidade nas transações

Métricas de iTLB: huge pages vs. páginas de 4 KB

iTLB data

Após ativar o Hugetext para o MySQL:

As falhas de iTLB caíram aproximadamente dez vezes.
A taxa de falhas do iTLB passou de ~0,09% para ~0,08%.
Houve redução de cerca de seis vezes nas falhas de iTLB por mil instruções (MPKI).

O PostgreSQL também pode aproveitar as huge pages para obter um aumento de 7% no desempenho.

Conceitos principais

Termo	Descrição
Huge page	Página de memória maior que o padrão de 4 KB. Reduz a quantidade de entradas necessárias no Translation Lookaside Buffer (TLB) e torna o acesso à memória mais eficiente.
Transparent Huge Pages (THP)	Recurso do kernel que consolida assincronamente páginas pequenas em huge pages de 2 MB ao examinar a área de memória virtual (VMA) de cada processo. O THP foca na memória anônima.
Hugetext	Extensão do THP que consolida exclusivamente segmentos de código em huge pages, atuando sobre seções executáveis de binários e DLLs.
Falha de iTLB	Ocorre quando a CPU não encontra uma entrada correspondente no instruction TLB (iTLB). Uma taxa elevada de falhas compromete o throughput da CPU.
Utilização do iTLB	Proporção de entradas do iTLB em uso ativo. Maior utilização resulta em menos falhas e melhor throughput da CPU.
MPKI do iTLB	Falhas de iTLB por mil instruções. Valores menores indicam maior eficiência da CPU.

Próximos passos

O Alibaba Cloud Linux também oferece suporte ao THP padrão para melhorar a eficiência de acesso à memória nos segmentos de dados. O THP consolida páginas de 4 KB em huge pages de 2 MB ou mais, diminuindo as entradas da tabela de páginas (PTEs) e a pressão sobre o TLB em todos os tipos de memória. Para mais informações, consulte Como usar o THP para ajustar o desempenho no Alibaba Cloud Linux?