Eu preciso testar um processo para gerenciamento de memória.
limitmemory 400k -p <pid>
Existe uma maneira de fazer isso no unix? Qualquer utilitário unix comum seria excelente.
ulimit -v , é um shell embutido, mas deve fazer o que você quiser.
Eu uso isso em scripts de inicialização, às vezes:
ulimit -v 128k
command
ulimit -v unlimited
No entanto, parece que você deseja manipular a memória máxima alocável enquanto o programa está em execução, correto? Provavelmente algo como renice para manipular a Prioridade.
Não existe, no entanto, tal ferramenta que eu saiba.
Não tenho muita certeza sobre isso, mas você também pode usar cgroups para limitar o uso de memória . A vantagem dos cgroups é que você pode controlar processos que já estão em execução. A propósito, systemd usará os cgroups para controlar os serviços do sistema.
Infelizmente eu experimentei um pouco e eles não funcionam muito bem no meu sistema Fedora 13.
Para definir o limite ao iniciar o programa, use ulimit -v 400 , conforme indicado por polemon . Isso define o limite para o shell e todos os seus descendentes, portanto, em um script, talvez você queira usar algo como (ulimit -v 400; myprogram) para limitar o escopo.
Se você precisar alterar o limite de um processo em execução, não há utilidade para isso. Você precisa obter o processo para executar a chamada do sistema setrlimit . Isso geralmente pode ser feito com um depurador, embora nem sempre funcione de maneira confiável. Veja como você pode fazer isso com o gdb (não testado; 9 é o valor de RLIMIT_AS no Linux):
gdb -n -pid $pid -batch -x /dev/stdin <<EOF
call setrlimit(9, {409600, -1})
detach
quit
EOF
Em sistemas Linux com kernel > = 2.6.36 e util-linux > = 2.21, você pode usar o prlimit comando para definir um limite de recursos de processo:
prlimit --rss=400000 --pid <pid>
Se você estiver usando o systemd, poderá definir algumas opções adicionais em um arquivo .service . A lista completa das opções que você pode definir é descrita aqui .
Abaixo está um pequeno exemplo que mostra como usar esse recurso do systemd:
# cat /etc/systemd/system/qbittorrent-nox.service
[Unit]
Description=qbittorrent-nox
Documentation=man:qbittorrent-nox
DefaultDependencies=yes
Requires=media-Kabi.mount
After=media-Kabi.mount network-online.target
Before=multi-user.target
Conflicts=umount.target
[Service]
User=morfik
Group=p2p
Type= simple
RemainAfterExit=no
ExecStart=/usr/bin/qbittorrent-nox
Nice=19
IOSchedulingClass=idle
PrivateNetwork=no
CPUShares=256
MemoryLimit=50M
BlockIOWeight=128
Slice=p2p.slice
StandardError=null
StandardOutput=null
[Install]
WantedBy=multi-user.target
Claro, você não precisa de todas as opções que usei. Se você quiser apenas limitar o uso de memória, adicione MemoryLimit=50M , que limita a 50 MiB.
E este é o resultado:
# systemctl status qbittorrent-nox.service
● qbittorrent-nox.service - qbittorrent-nox
Loaded: loaded (/etc/systemd/system/qbittorrent-nox.service; enabled; vendor preset: enabled)
Active: active (running) since Thu 2015-05-07 19:25:20 CEST; 1s ago
Docs: man:qbittorrent-nox
Main PID: 21712 (qbittorrent-nox)
Memory: 9.4M (limit: 50.0M)
CGroup: /p2p.slice/qbittorrent-nox.service
└─21712 /usr/bin/qbittorrent-nox
May 07 19:25:20 morfikownia systemd[1]: Started qbittorrent-nox.
May 07 19:25:20 morfikownia systemd[1]: Starting qbittorrent-nox...
Até agora, isso funciona apenas para daemons / serviços do sistema, e você não pode limitar, por exemplo, um processo do firefox como um usuário comum dessa maneira. Mas talvez isso mude algum dia .
Existe a função setrlimit () , que permite configurar os limites de um processo em C. Escreva um Programa C para chamar setrlimit e executar o comando que você deseja que seja limitado. setrlimit não pode alterar os limites de outros processos.
Felizmente, alguém já escreveu algo semelhante. Ele pode ser baixado de freshmeat . Eu dei uma rápida olhada no código fonte e parece estar bem. Use rlimit a seu próprio critério. Observe que o rlimit também não pode alterar os limites de outros processos.
Editar: Gilles propôs um bom hack com gdb: Anexe ao processo com gdb e então faça o processo chamar setrlimit. Isso talvez resolva o problema para limitar um processo já em andamento.
Se você quiser testar e medir o uso de memória de seu programa, consulte horário .
Você pode medir o uso de recursos do seu programa em muitos aspectos, incluindo os termos de tempo de CPU e uso de memória. O comando a seguir fornecerá o uso de memória e o tempo de uso da CPU de myProgram :
/usr/bin/time myProgram
(Certifique-se de fornecer o caminho absoluto para distingui-lo do comando de tempo interno do bash).
Se você quiser apenas limitar os recursos do seu processo, recomendo que você crie um usuário de teste para essa tarefa específica. Limite os recursos deste usuário de acordo com suas necessidades e execute o processo pelo usuário. Parece que, no mundo * nix, o gerenciamento de recursos baseado em usuários é muito mais avançado do que o gerenciamento de recursos baseado em processos.
Você pode verificar /etc/security/limits.conf para limitar os recursos de um usuário. Ou você pode usar ulimit depois de logado com o usuário limitado.