Recurso Page Cache Limit - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

Cargas de trabalho como o Apache Spark podem acumular grandes volumes de page cache em pouco tempo. A maioria dessas páginas são dirty pages, cuja recuperação é lenta. Se o mecanismo de reclaim não liberar memória com rapidez suficiente, o kernel fica sem memória e dispara um erro inesperado de out-of-memory (OOM), causando instabilidade nos serviços. O Page Cache Limit estabelece um teto para o uso de page cache por memory control group (memcg) e recupera o excesso quando esse limite é ultrapassado. Isso evita tanto o crescimento ilimitado do page cache quanto erros inesperados de OOM. Disponível no Alibaba Cloud Linux 3 a partir da versão do kernel 5.10.134-14.

Interfaces

A tabela a seguir resume todas as interfaces. As descrições detalhadas aparecem logo em seguida.

Interface	Descrição	Padrão
`/sys/kernel/mm/pagecache_limit/enabled`	Chave global de ativação/desativação	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.enable`	Chave de ativação/desativação por memcg	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.size`	Limite de page cache em bytes	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.sync`	Modo de reclaim: assíncrono (`0`) ou síncrono (`1`)	`0`

`/sys/kernel/mm/pagecache_limit/enabled`

Controla a chave global do Page Cache Limit. Valores válidos: 0 e 1.

1: ative o Page Cache Limit globalmente.
0: desativa o Page Cache Limit globalmente.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.enable`

Gerencia a chave específica de cada memcg. Valores válidos: 0 e 1.

1: ative o Page Cache Limit para o memcg.
0: desativa o Page Cache Limit para o memcg.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.size`

Define o uso máximo de page cache para um memcg, em bytes. Intervalo válido: de 0 até o valor de memory.limit_in_bytes do memcg.

0: desativa o Page Cache Limit para o memcg, independentemente da chave global ou individual.
Valor diferente de zero: restringe o uso de page cache do memcg a este valor.

Nota: O uso de page cache de um memcg corresponde à soma do uso de page cache de todos os seus memcgs filhos.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.sync`

Determina o modo de reclaim. Valores válidos: 0 e 1.

0: reclaim assíncrono. O kernel delega tarefas de reclaim a threads de workqueue em segundo plano, reduzindo o impacto nas threads principais. Se a carga de trabalho gerar page cache mais rápido do que o workqueue consegue recuperar, o page cache pode exceder temporariamente o limite.
1: reclaim síncrono. A recuperação ocorre no contexto do processo atual e o bloqueia até que haja liberação suficiente de page cache. Essa abordagem oferece garantias mais fortes, mas pode causar picos de latência no nível do processo.

Funcionamento

Ao ativar o Page Cache Limit, o kernel aplica a seguinte lógica sempre que aloca page cache para um processo do memcg:

Verifique o memcg atual. O kernel checa se o memcg ultrapassou seu limite de page cache. Em seguida, percorre a hierarquia do memcg para cima e examina os valores de memory.pagecache_limit de cada memcg pai. Se o valor de um pai for 0, o recurso fica desativado para esse pai e todos os seus descendentes. Nesse escopo, o page cache torna-se irrestrito.
Selecione o modo de reclaim. Quando o memcg excede o limite, o kernel consulta memory.pagecache_limit.sync para decidir entre reclaim assíncrono e síncrono.

Recupera o page cache. O comportamento de reclaim varia conforme o modo:

Modo	Alvos de reclaim
Síncrono	Por padrão, apenas páginas de arquivo não mapeadas. Após mais de quatro varreduras, páginas de arquivo mapeadas também se tornam elegíveis.
Assíncrono	Por padrão, páginas de arquivo mapeadas e não mapeadas. Depois de mais de duas varreduras, dirty pages também entram na lista de elegíveis.

O diagrama abaixo ilustra o fluxo completo:

Tipos de página de memória

Tipo	Descrição
Páginas de arquivo não mapeadas	Páginas sem mapeamento para nenhum arquivo. Geralmente contêm dados privados e temporários que não persistem em disco.
Páginas de arquivo mapeadas	Páginas vinculadas a arquivos. Permitem que processos leiam e gravem dados de arquivos diretamente na memória.
Dirty pages	Páginas de arquivo mapeadas modificadas, mas ainda não gravadas de volta no disco. A recuperação é lenta porque exigem flush prévio.

Configure o Page Cache Limit

Este exemplo crie um page cache de 20 MiB, impõe um limite de 10 MiB e verifique se o recurso recupera o excesso corretamente.

Pré-requisitos

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

Uma instância Elastic Compute Service (ECS) executando Alibaba Cloud Linux 3, com versão do kernel 5.10.134-14 ou superior
Acesso sudo na instância

Ative e configure o recurso

Conecte-se à instância ECS. Para obter instruções, consulte Usar o Workbench para fazer login em uma instância Linux.

Ative o Page Cache Limit globalmente.

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

Crie um diretório memcg. Este exemplo utiliza /sys/fs/cgroup/memory/test/.
```
sudo mkdir -p /sys/fs/cgroup/memory/test/
```

Defina o limite de page cache como 10 MiB (10.485.760 bytes).

sudo sh -c 'echo 10485760 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.size'

Configure o modo de reclaim. Escolha uma das opções abaixo conforme sua carga de trabalho:

Reclaim assíncrono:

sudo sh -c 'echo 0 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.sync'

Reclaim síncrono:

sudo sh -c 'echo 1 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.sync'

Ative o Page Cache Limit para o memcg.

sudo sh -c 'echo 1 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.enable'

Crie um page cache de teste

Instale o pacote libcgroup, que fornece o comando cgexec.
```
sudo yum install libcgroup-tools
```

Gere um arquivo de teste de 20 MiB e leia-o sob o memcg test para produzir 20 MiB de page cache.

sudo dd if=/dev/zero of=./testfile bs=1M count=20 oflag=direct
sudo cgexec -g "memory:test" cat ./testfile > /dev/null

Verifique os resultados

Consulte o uso de page cache. O campo cache em memory.stat exibe o total de page cache consumido pelo memcg.
```
grep cache /sys/fs/cgroup/memory/test/memory.stat
```
A saída deve mostrar cache com aproximadamente 10.543.104 bytes (~10 MiB), confirmando que o uso de page cache está limitado ao valor configurado.
Verifique quanto page cache foi recuperado. O campo pagecache_limit_reclaimed_kb em memory.exstat indica o total acumulado de kilobytes de page cache recuperados pelo recurso.
```
cat /sys/fs/cgroup/memory/test/memory.exstat
```
A saída deve apresentar pagecache_limit_reclaimed_kb próximo de 10.108 KB (~10 MiB), comprovando que 10 MiB de page cache excedente foram recuperados.

Resultado: Um page cache de 20 MiB foi criado. O Page Cache Limit restringiu o uso a 10 MiB e recuperou os 10 MiB restantes conforme esperado.

Nota: Se pagecache_limit_reclaimed_kb estiver acima do esperado, leituras sequenciais excessivas de read-ahead podem ser a causa. Reduza o tamanho de read-ahead do dispositivo de disco e teste novamente: echo 128 | sudo tee /sys/block/<disk-device>/queue/read_ahead_kb Substitua <disk-device> pelo nome do seu dispositivo de disco (por exemplo, vda ). O parâmetro read_ahead_kb controla quantos kilobytes o kernel pré-carrega durante leituras sequenciais. Diminuir esse valor reduz alocações desnecessárias de page cache.

Próximos passos

Reclaim assíncrono de backend memcg — Conheça o recurso complementar que lida com pressão típica de memória sem bloquear processos.