Como preencher 90% da memória livre?

Quero fazer alguns testes com poucos recursos e para isso preciso ter 90% da memória livre cheia.

Como posso fazer isso em um *nixsistema?

stress-ng é um gerador de carga de trabalho que simula o estresse da cpu / mem / io / hdd nos sistemas POSIX. Essa chamada deve funcionar no Linux <3.14:

stress-ng --vm-bytes $(awk '/MemFree/{printf "%d\n", $2 * 0.9;}' < /proc/meminfo)k --vm-keep -m 1

Para Linux> = 3.14, você pode usar MemAvailablepara estimar a memória disponível para novos processos sem trocar:

stress-ng --vm-bytes $(awk '/MemAvailable/{printf "%d\n", $2 * 0.9;}' < /proc/meminfo)k --vm-keep -m 1

Adapte a /proc/meminfochamada com free(1)/ vm_stat(1)/ etc. se você precisar dele portátil.

Você pode gravar um programa C malloc()na memória necessária e depois usá-lo mlock()para impedir que a memória seja trocada.

Em seguida, deixe o programa aguardar a entrada do teclado e desbloqueie a memória, libere a memória e saia.

Eu sugeriria executar uma VM com memória limitada e testar o software, o que seria um teste mais eficiente do que tentar preencher a memória na máquina host.

Esse método também tem a vantagem de que, se a situação de pouca memória causar erros de OOM em outro local e travar todo o sistema operacional, você apenas trava a VM que está testando na sua máquina, na qual poderá ter outros processos úteis em execução.

Além disso, se seu teste não for intensivo em CPU ou IO, você poderá executar simultaneamente instâncias dos testes em uma família de VMs com uma variedade de tamanhos de memória baixos.

Deste comentário do HN: https://news.ycombinator.com/item?id=6695581

Basta preencher / dev / shm via dd ou similar.

swapoff -a
dd if=/dev/zero of=/dev/shm/fill bs=1k count=1024k

1. execute linux;
2. inicializar com mem=nn[KMG]o parâmetro de inicialização do kernel

(veja em linux / Documentation / kernel-parameters.txt para detalhes).

Se você tiver ferramentas GNU básicos ( sh, grep, yese head) você pode fazer isso:

yes | tr \\n x | head -c $BYTES | grep n
# Protip: use `head -c $((1024*1024*2))` to calculate 2MB easily

Isso funciona porque o grep carrega toda a linha de dados na RAM (eu aprendi isso de uma maneira bastante infeliz ao receber uma imagem de disco). A linha, gerado por yes, novas linhas substituindo, será infinitamente longo, mas é limitado headpela $BYTESbytes, assim grep irá carregar $ bytes de memória. O próprio Grep usa como 100-200KB para mim, pode ser necessário subtraí-lo para uma quantidade mais precisa.

Se você também deseja adicionar uma restrição de tempo, isso pode ser feito facilmente bash(não funcionará sh):

cat <(yes | tr \\n x | head -c $BYTES) <(sleep $NumberOfSeconds) | grep n

A <(command)coisa parece ser pouco conhecida, mas geralmente é extremamente útil, mais informações aqui: http://tldp.org/LDP/abs/html/process-sub.html

Então, o uso de cat: cataguardará a conclusão das entradas até a saída e, mantendo um dos tubos abertos, manterá o grep ativo.

Se você tem pve deseja aumentar lentamente o uso da RAM:

yes | tr \\n x | head -c $BYTES | pv -L $BYTESPERSEC | grep n

Por exemplo:

yes | tr \\n x | head -c $((1024*1024*1024)) | pv -L $((1024*1024)) | grep n

Usará até um gigabyte a uma taxa de 1 MB por segundo. Como um bônus adicional, pvmostrará a taxa atual de uso e o uso total até o momento. Claro que isso também pode ser feito com variantes anteriores:

yes | tr \\n x | head -c $BYTES | pv | grep n

Apenas inserir a | pv |peça mostrará o status atual (taxa de transferência e total, por padrão, eu acho - caso contrário, veja a página do manual).

Por que outra resposta? A resposta aceita recomenda a instalação de um pacote (aposto que há uma liberação para cada chipset sem a necessidade de um gerenciador de pacotes); a resposta mais votada recomenda a compilação de um programa C (eu não tinha um compilador ou uma cadeia de ferramentas instalada para compilar para sua plataforma de destino); a segunda resposta mais votada recomenda a execução do aplicativo em uma VM (sim, deixe-me colocar o sdcard interno do telefone por USB ou algo assim e criar uma imagem de caixa virtual); o terceiro sugere modificar algo na sequência de inicialização que não preenche a RAM conforme desejado; o quarto funciona apenas na medida em que o ponto de montagem / dev / shm (1) existe e (2) é grande (a remontagem precisa de raiz); o quinto combina muitos dos itens acima sem código de exemplo; a sexta é uma ótima resposta, mas eu não a vi antes de apresentar minha própria abordagem, então pensei em adicionar o meu, também porque é mais curto lembrar ou digitar, se você não perceber que a linha memblob é realmente o cerne da questão; o sétimo novamente não responde à pergunta (usa ulimit para limitar um processo); o oitavo tenta fazer com que você instale o python; o nono acha que somos todos muito pouco criativos e, finalmente, o décimo escreveu seu próprio programa C ++, que causa o mesmo problema que a resposta mais votada.

Eu mantenho uma função para fazer algo semelhante nos meus arquivos de ponto. https://github.com/sagotsky/.dotfiles/blob/master/.functions#L248

function malloc() {
  if [[ $# -eq 0 || $1 -eq '-h' || $1 -lt 0 ]] ; then
    echo -e "usage: malloc N\n\nAllocate N mb, wait, then release it."
  else 
    N=$(free -m | grep Mem: | awk '{print int($2/10)}')
    if [[ $N -gt $1 ]] ;then 
      N=$1
    fi
    sh -c "MEMBLOB=\$(dd if=/dev/urandom bs=1MB count=$N) ; sleep 1"
  fi
}

Como montar uma solução python simples?

#!/usr/bin/env python

import sys
import time

if len(sys.argv) != 2:
    print "usage: fillmem <number-of-megabytes>"
    sys.exit()

count = int(sys.argv[1])

megabyte = (0,) * (1024 * 1024 / 8)

data = megabyte * count

while True:
    time.sleep(1)

Que tal ramfs, se existir? Montá-lo e copiar sobre um arquivo grande? Se não houver /dev/shme não ramfs - eu acho que um pequeno programa C que faz um malloc grande com base em algum valor de entrada? Pode ser necessário executá-lo algumas vezes ao mesmo tempo em um sistema de 32 bits com muita memória.

Se você quiser testar um processo específico com memória limitada, poderá utilizar melhor ulimitpara restringir a quantidade de memória alocável.

Penso que este é um caso de fazer a pergunta errada e a sanidade serem abafadas por pessoas que competem pela resposta mais criativa. Se você precisar simular apenas condições de OOM, não precisará preencher memória. Basta usar um alocador personalizado e fazer com que ele falhe após um certo número de alocações. Essa abordagem parece funcionar bem o suficiente para o SQLite .

Eu escrevi este pequeno programa C ++ para isso: https://github.com/rmetzger/dynamic-ballooner

A vantagem dessa implementação é que periodicamente verifica se é necessário liberar ou realocar a memória.