Fazendo o Linux ler swap de volta na memória

Question

O kernel do Linux substitui a maioria das páginas da memória quando eu executo um aplicativo que usa a maioria dos 16GB de memória física. Após o término do aplicativo, cada ação (digitar comandos, alternar espaços de trabalho, abrir uma nova página da Web etc.) leva muito tempo para ser concluída, pois as páginas relevantes precisam ser lidas de volta pela primeira vez a partir do swap.

Existe uma maneira de dizer ao kernel do Linux para copiar as páginas da troca de volta para a memória física sem tocar manualmente (e aguardar) cada aplicativo? Eu corro muitos aplicativos para que a espera seja sempre dolorosa.

Costumo usar swapoff -a && swapon -a para tornar o sistema responsivo novamente, mas isso limpa as páginas do swap, então elas precisam ser escritas novamente na próxima vez que eu executar o script.

Existe uma interface de kernel, talvez usando o sysfs, para instruir o kernel a ler todas as páginas do swap?

Edit: Eu estou realmente procurando uma maneira de fazer todo swap swapcached. (Obrigado derobert!)

[P.S. serverfault.com/questions/153946/… e serverfault.com/questions/100448/… são tópicos relacionados, mas não abordam a questão de como fazer com que o kernel do Linux copie páginas da troca de volta para a memória sem limpar a troca.]

    

Answer 1

Baseado no programa memdump originalmente encontrado aqui Criei um script para a leitura seletiva de aplicativos especificados de volta à memória. remember :

#!/bin/bash
declare -A Q
for i in "$@"; do
    E=$(readlink /proc/$i/exe);
    if [ -z "$E" ]; then.
        #echo skipped $i;.
        continue;.
    fi
    if echo $E | grep -qF memdump; then.
        #echo skipped $i >&2;.
        continue;.
    fi
    if [ -n "${Q[${E}]}" ]; then.
        #echo already $i >&2;.
        continue;.
    fi
    echo "$i $E" >&2
    memdump $i 2> /dev/null
    Q[$E]=$i
done | pv -c -i 2 > /dev/null

Uso: algo como

# ./remember $(< /mnt/cgroup/tasks )
1 /sbin/init
882 /bin/bash
1301 /usr/bin/hexchat
...
2.21GiB 0:00:02 [ 1.1GiB/s] [  <=>     ]
...
6838 /sbin/agetty
11.6GiB 0:00:10 [1.16GiB/s] [      <=> ]
...
23.7GiB 0:00:38 [ 637MiB/s] [   <=>    ]
# 

Ele pula rapidamente a memória não-trocada (gigabytes por segundo) e desacelera quando a troca é necessária.

    

Answer 2

Pode ajudar a aumentar /proc/sys/vm/page-cluster (padrão: 3).

Da documentação do kernel ( sysctl/vm.txt ):

page-cluster

page-cluster controls the number of pages up to which consecutive pages are read in from swap in a single attempt. This is the swap counterpart to page cache readahead. The mentioned consecutivity is not in terms of virtual/physical addresses, but consecutive on swap space - that means they were swapped out together.

It is a logarithmic value - setting it to zero means "1 page", setting it to 1 means "2 pages", setting it to 2 means "4 pages", etc. Zero disables swap readahead completely.

The default value is three (eight pages at a time). There may be some small benefits in tuning this to a different value if your workload is swap-intensive.

Lower values mean lower latencies for initial faults, but at the same time extra faults and I/O delays for following faults if they would have been part of that consecutive pages readahead would have brought in.

A documentação não menciona um limite, então possivelmente você poderia definir isso absurdamente alto para fazer toda a troca ser lida de volta em breve. E, claro, voltar a um valor sano depois.

    

Answer 3

Você pode tentar adicionar os programas com os quais você mais se importa para um cgroup e tuning swappiness para que, da próxima vez que o aplicativo for executado, os programas adicionados sejam menos prováveis de serem candidatos a troca.

Algumas de suas páginas provavelmente ainda serão trocadas, mas podem prejudicar seus problemas de desempenho. Uma grande parte dele é provavelmente apenas o comportamento "parar e iniciar" quando muitas páginas de um programa estão em swap e o programa tem que pausar continuamente para trocar suas páginas em RAM, mas apenas em incrementos de 4k.

Como alternativa, você pode adicionar o aplicativo que está sendo executado em um cgroup e ajustar o swappiness para que o aplicativo seja aquele que tende a usar mais o arquivo de troca. Isso vai atrasar o aplicativo, mas poupará o resto do sistema.

    

Answer 4

Parece-me que você não pode magicamente "tornar o sistema responsivo novamente". Você incorre na penalidade ou lê as páginas de volta do espaço de troca na memória agora ou incorre em mais tarde, mas de uma forma ou de outra, você a incorre. De fato, se você faz algo como swapoff -a && swapon -a , então você pode sentir mais dor ao invés de menos, porque você força algumas páginas a serem copiadas de volta para a memória que de outra forma nunca seriam necessárias novamente sendo lido (pense: você encerrou um aplicativo enquanto grande parte do seu heap foi desfeita; essas páginas podem ser descartadas de uma vez sem serem lidas novamente na memória).

but this clears the pages from swap, so they need to be written again the next time I run the script.

Bem, praticamente qualquer página que é copiada de volta para a memória principal está prestes a ser modificada de qualquer maneira, então se ela precisasse ser movida de volta para trocar novamente no futuro, ela teria que ser escrita de novo troque de qualquer maneira. Tenha em mente que swap é principalmente memória heap, não páginas somente leitura (que geralmente são suportadas por arquivos).

Acho que seu truque swapoff -a && swapon -a é tão bom quanto qualquer coisa que você possa criar.

    

Answer 5

Existe uma discussão muito interessante aqui link o que se resume a uma troca decrescente, com a ideia de que, para aumentar a capacidade de resposta percebida do sistema, deve-se evitar trocar o código (e é isso que acontece). Esta não é realmente uma resposta à sua pergunta, mas isso pode impedir que o problema apareça (seus aplicativos não são trocados, apenas dados não utilizados e cache de páginas)