Quanta memória posso bloquear antes de o sistema iniciar a troca / espelhamento?

Question

Estou tentando usar o Memtester como teste de estresse e correção de memória para as caixas Linux da minha organização . O Memtester basicamente absorve uma quantidade de memória para testar como um argumento, bloqueia muita memória usando memlock() e, em seguida, executa vários padrões para verificar se a memória é boa.

Como estou tentando verificar a exatidão, quero testar o máximo possível de memória da máquina. Eu tenho tentado fazer isso passando MemFree de / proc / meminfo. Ou melhor, eu tenho um script que gera vários processos, cada um pedindo MemFree (veja abaixo), porque o sistema operacional não permite que um único processo bloqueie mais de 50% da memória.

O problema é que, se eu bloquear mais de ~ 90% da memória, meu computador trava, presumivelmente devido a uma surra. Cerca de 30 minutos depois, finalmente posso usá-lo novamente.

Existe uma maneira, programaticamente ou não, de descobrir quanta memória eu posso bloquear antes de começar a trocar?

Eu quero que isso seja executado em qualquer caixa do Linux, então qualquer coisa que me obrigue a alterar a configuração do sistema é um não-ir. Além disso, você pode assumir que o teste será a única coisa em execução no sistema (além do material normal do sistema operacional, é claro), já que as máquinas devem ser deixadas sozinhas enquanto estamos testando o estresse.

parte do script que gera processos do memtester

    while [ $MEMAVAILABLE -ge 0 ] 
    do
        ./memtester $MEMAVAILABLE'K' &
        sleep 10 #wait for previous process to lock its memory
        MEMFREE='cat /proc/meminfo | grep "MemFree" | sed 's/MemFree:\(\s\)*\(.*\) kB//g''
        MEMAVAILABLE=$(($MEMFREE-($MEMTOTAL*5/100)))
    done
    wait

.

    

Answer 1

Seu script provavelmente aloca muito por causa da condição de corrida. Na declaração1 & statement2, o statement2 pode executar mais cedo e o loop continuará. E assim por diante.

Você não pode alocar mais memória? Eu acho que tentaria jogar com ulimit .

Agora, para o ponto principal - quanto mem. O Linux não funciona em um modelo semelhante ao DOS, no que diz respeito à memória "livre". A métrica MemFree deve ser realmente chamada MemFreeImmediatelyAvailable. Você pode alocar longe, muito mais do que isso, e nada aconteceria além de talvez um pouco de paginação. Mas se você usar memória, isso não significa que o MemFree iria diminuir - o kernel converterá Inact_clean para MemFree assim que possível, para manter um certo tamanho mínimo de MemFree (outra razão pela qual seu script usará muito). Um grande exemplo da categoria Inact_clean é geralmente o cache de leitura para o sistema de arquivos - o kernel pode imediatamente "soltar" o programa, já que o programa precisa de mais memória. Eu não estou dizendo que você pode consumir todo , mas em grande parte, sim, você pode.

• Active: Memory that has been used more recently and usually not reclaimed unless absolutely necessary.
• Inact_dirty: Dirty means "might need writing to disk or swap." Takes more work to free. Examples might be files that have not been written to yet. They aren't written to memory too soon in order to keep the I/O down. For instance, if you're writing logs, it might be better to wait until you have a complete log ready before sending it to disk.
• Inact_clean: Assumed to be easily freeable. The kernel will try to keep some clean stuff around always to have a bit of breathing room.
• Inact_target: Just a goal metric the kernel uses for making sure there are enough inactive pages around. When exceeded, the kernel will not do work to move pages from active to inactive. A page can also get inactive in a few other ways, e.g. if you do a long sequential I/O, the kernel assumes you're not going to use that memory and makes it inactive preventively. So you can get more inactive pages than the target because the kernel marks some cache as "more likely to be never used" and lets it cheat in the "last used" order.

link

Por último, acho isso um equivalente mais elegante:

sed -n '/MemFree/s/.*MemFree:\s*\([0-9]*\) kB.*//gp' /proc/meminfo