Fazendo a leitura do Linux trocar de volta para a memória

O kernel do Linux troca a maioria das páginas da memória quando executo um aplicativo que utiliza a maioria dos 16 GB de memória física. Após o término do aplicativo, todas as ações (digitando comandos, alternando áreas de trabalho, abrindo uma nova página da web etc.) levam muito tempo para serem concluídas porque as páginas relevantes primeiro precisam ser lidas novamente no swap.

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

Costumo usar swapoff -a && swapon -apara tornar o sistema responsivo novamente, mas isso limpa as páginas da troca, portanto elas precisam ser gravadas novamente na próxima vez que executar o script.

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

Edit: Na verdade, estou procurando uma maneira de fazer todos os swap swapcached. (Obrigado derobert!)

[PS 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 Linux copie as páginas do swap de volta para a memória sem limpar a troca.]

Baseado no programa memdump originalmente encontrado aqui , criei um script para ler seletivamente os 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 diminui a velocidade quando a troca é necessária.

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

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

cluster de páginas

O cluster de páginas controla o número de páginas nas quais as páginas consecutivas são lidas na troca em uma única tentativa. Esta é a contrapartida de troca para o readahead do cache da página. A consecutividade mencionada não é em termos de endereços virtuais / físicos, mas consecutiva no espaço de troca - isso significa que eles foram trocados juntos.

É um valor logarítmico - defini-lo como zero significa "1 página", defini-lo como 1 significa "2 páginas", defini-lo como 2 significa "4 páginas", etc. Zero desativa completamente o cabeçote de leitura de troca.

O valor padrão é três (oito páginas por vez). Pode haver alguns pequenos benefícios em ajustar isso para um valor diferente se a sua carga de trabalho exigir muito uso de trocas.

Valores mais baixos significam latências mais baixas para falhas iniciais, mas, ao mesmo tempo, falhas extras e atrasos de E / S para as seguintes falhas, se elas fizessem parte das páginas consecutivas que o readahead teria trazido.

A documentação não menciona um limite, portanto, você pode definir um valor absurdamente alto para fazer com que toda a troca seja lida em breve. E, é claro, volte a um valor sensato depois.

Você pode tentar adicionar os programas mais importantes a um cgroup e ajustar a alternância, para que na próxima vez que o aplicativo execute os programas adicionados, seja menos provável que sejam candidatos à troca.

Algumas de suas páginas provavelmente ainda serão trocadas, mas isso pode solucionar seus problemas de desempenho. Uma grande parte provavelmente é apenas o comportamento de "parar e iniciar" quando muitas páginas de um programa estão em troca e o programa precisa pausar continuamente para trocar suas páginas na RAM, mas apenas em incrementos de 4k.

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

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 mais tarde, mas de uma forma ou de outra incorre. De fato, se você fizer algo assim swapoff -a && swapon -a, poderá sentir mais dor do que menos, porque força algumas páginas a serem copiadas de volta para a memória que, de outra forma, nunca seriam necessárias novamente e eventualmente caíram sem serem lidas (pense: você saiu de um aplicativo enquanto grande parte de sua pilha é trocada; essas páginas podem ser descartadas completamente sem nunca serem lidas na memória).

mas isso limpa as páginas da troca, então elas precisam ser escritas novamente na próxima vez que eu executar o script.

Bem, praticamente qualquer página que é copiada de volta do swap para a memória principal está prestes a ser modificada de qualquer maneira, portanto, se alguma vez precisar ser movida novamente para trocar novamente no futuro, ela terá que ser escrita novamente no swap de qualquer maneira. Lembre-se de que swap é principalmente memória de pilha, e não páginas somente leitura (que geralmente são suportadas por arquivos).

Eu acho que seu swapoff -a && swapon -atruque é tão bom quanto qualquer coisa que você possa inventar.

Há uma discussão muito boa aqui http://rudd-o.com/en/linux-and-free-software/tales-from-responsivenessland-why-linux-feels-slow-and-how-to-fix-that que se resume à diminuição da troca, com a idéia de que, para aumentar a capacidade de resposta percebida do sistema, deve-se evitar a troca do código (e é isso que acontece). Essa não é realmente uma resposta para sua pergunta, mas isso pode impedir que o problema apareça (seus aplicativos simplesmente não são trocados, apenas dados não utilizados e cache de página)