use o recurso code duptext para evitar latência de acesso entre nós na arquitetura NUMA - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

Em arquiteturas de acesso não uniforme à memória (NUMA), especialmente em instâncias baseadas em ARM, processos podem acessar segmentos de código armazenados em um nó NUMA remoto em vez do nó local. Esse acesso entre nós aumenta a latência e o consumo de largura de banda da memória. O recurso code duptext elimina essa sobrecarga copiando segmentos de código remotos para o nó local, permitindo que os processos leiam diretamente da memória local.

Como funciona

Quando o kernel detecta que um processo em um nó NUMA acessa segmentos de código em outro nó, ele cria uma cópia local com granularidade de página (cada página tem 4 KB):

Um processo no nó 1 acessa libc.so armazenado no nó 0, ou um processo no nó 0 acessa test armazenado no nó 1.
O kernel cria uma cópia do segmento de código remoto no nó local: uma cópia de libc.so no nó 1 e uma cópia de test no nó 0.
Cada processo lê sua cópia local, eliminando o acesso entre nós.

A página original que contém o segmento de código é chamada de página principal. A cópia local criada pelo recurso duptext é chamada de subpágina.

O sistema operacional pode alocar memória em vários nós NUMA para aliviar a pressão de memória ou atender a requisitos de balanceamento de carga, causando acesso a código entre nós. Ative o recurso code duptext é a mitigação recomendada.

Limites

O recurso code duptext exige os seguintes requisitos:

Tipo de instância: Famílias de ECS Bare Metal Instance. Para mais informações, consulte Visão geral.
Imagem: Alibaba Cloud Linux 3 com versão do kernel 5.10.112-11 ou posterior.

Para verificar a versão do kernel da instância, execute:

uname -r

Chaves de ativação

O recurso possui duas chaves de ativação: uma global e outra por memcg. Ambas devem estar ativadas para que o kernel crie subpáginas para um processo.

Chave	Descrição	Padrão
`/sys/kernel/mm/duptext/enabled`	Chave global. Defina como `1` para ativar o recurso em todo o sistema; defina como `0` para desativá-lo.	`0`
`/sys/fs/cgroup/memory/<memcg-dir>/memory.allow_duptext`	Chave por memcg. Defina como `1` para ativar o recurso para todos os processos nesse memcg; defina como `0` para desativá-lo.	`0`

Quando a chave global é definida como 0 , o kernel limpa automaticamente todas as subpáginas na instância.

Monitorar subpáginas

Use os arquivos a seguir para verificar a atividade do duptext:

Arquivo ou campo	O que exibe
`nr_duptext` em `/proc/vmstat`	Quantidade de subpáginas marcadas como duptext no kernel. Um valor maior que zero confirma a criação ativa de subpáginas. Se o valor permanecer em zero após a ativação do recurso, nenhum acesso a código entre nós foi detectado.
`DupText` em `/proc/meminfo`	Memória total usada pelas subpáginas duptext, em KB.
`/proc/<pid>/smaps`	Estatísticas de subpáginas por processo. O campo `DupText` na saída confirma se uma subpágina foi criada no nó local para esse processo.

Ativar o recurso code duptext

Este exemplo compila e executa um programa de teste em uma instância NUMA de dois nós.

Pré-requisitos

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

Uma ECS Bare Metal Instance executando Alibaba Cloud Linux 3 (5.10.112-11 ou posterior)
Acesso root ou sudo

Etapas

Conecte-se à instância ECS. Para obter instruções, consulte Usar o Workbench para conectar-se a uma instância Linux via SSH.
(Opcional) Visualize a topologia NUMA da instância:

Se o numactl não estiver instalado, execute sudo yum install numactl primeiro.
```
numactl -H
```
A saída lista todos os nós NUMA. O exemplo a seguir mostra uma instância de dois nós com o nó 0 e o nó 1.
Compile o programa de teste no nó 1 para que ele mantenha o cache de páginas do binário test:
```
numactl -N 1 -m 1 gcc test.c -o test
```

Ative a chave global:

sudo sh -c 'echo 1 > /sys/kernel/mm/duptext/enabled'

Crie um diretório memcg e ative o recurso duptext para ele:

sudo mkdir /sys/fs/cgroup/memory/test
sudo sh -c 'echo 1 > /sys/fs/cgroup/memory/test/memory.allow_duptext'

Execute o binário test sob o memcg, vinculado ao nó 0. O kernel detecta o acesso entre nós e cria uma cópia de subpágina do segmento de código test no nó 0:

Se o cgexec não estiver instalado, execute sudo yum install -y libcgroup-tools primeiro.
```
sudo cgexec -g "memory:test" numactl -N 0 -m 0 ./test
```
Verifique se uma subpágina foi criada para o processo test:
```
sudo cat /proc/$(pidof test)/smaps
```
O campo DupText na saída confirma a criação de uma cópia de subpágina no nó 0.

Para verificar as estatísticas de duptext no nível da instância, execute:
```
cat /proc/vmstat | grep -i duptext
cat /proc/meminfo | grep -i duptext
```
Se nr_duptext for maior que zero, o recurso está criando subpáginas ativamente.

Desativar o recurso code duptext

Desative o recurso code duptext conforme suas necessidades de negócios. Quando desativado, o kernel limpa automaticamente todas as subpáginas na instância.

Conecte-se à instância ECS. Para obter instruções, consulte Usar o Workbench para conectar-se a uma instância Linux via SSH.

Desative a chave global:

sudo sh -c 'echo 0 > /sys/kernel/mm/duptext/enabled'

Verifique se todas as subpáginas foram limpas:
```
cat /proc/vmstat | grep -i duptext
cat /proc/meminfo | grep -i duptext
```
Ambos os valores devem ser 0, confirmando que o recurso está desativado e todas as subpáginas foram recuperadas.