Uso da memória de limite paralelo GNU

Question

É possível limitar o uso de memória de todos os processos iniciados pelo GNU paralelo? Percebo que existem maneiras de limitar o número de trabalhos, mas, nos casos em que não é fácil prever o uso de memória com antecedência, pode ser difícil ajustar esse parâmetro.

No meu caso particular, estou executando programas em um HPC, onde há limites rígidos na memória de processo. Por exemplo. Se houver 72 GB de RAM disponíveis em um nó, o sistema em lotes eliminará os trabalhos que excederem 70 GB. Eu também sou incapaz de gerar trabalhos diretamente para o swap e mantê-los lá.

O pacote paralelo GNU vem com niceload , o que parece permitir que o uso de memória atual seja verificado antes que um processo seja executado. No entanto, não tenho certeza de como usar isso.

    

Answer 1

A resposta curta é:

ulimit -m 1000000
ulimit -v 1000000

que limitará cada processo a 1 GB de RAM.

Limitar a memória do modo "certo" é, na prática, extremamente complicado: digamos que você tenha 1 GB de RAM. Você inicia um processo a cada 10 segundos e cada processo usa 1 MB a mais a cada segundo. Então, depois de 140 segundos, você terá algo assim:

10██▎                                                          
20██████▍                                                      
30██████████▌                                                  
40██████████████▋                                              
50██████████████████▊                                          
60██████████████████████▉                                      
70███████████████████████████                                  
80███████████████████████████████▏                             
90███████████████████████████████████▎                         
100██████████████████████████████████████▍                     
110██████████████████████████████████████████▌                 
120██████████████████████████████████████████████▋             
130██████████████████████████████████████████████████▊         
140██████████████████████████████████████████████████████▉     

Isso soma até 1050 MB de RAM, então agora você precisa matar alguma coisa. Qual é o trabalho certo para matar? É 140 (supondo que correu descontroladamente)? É 10 (porque corre a menor quantidade de tempo)?

Na minha experiência, trabalhos em que a memória é um problema são tipicamente muito previsíveis (por exemplo, transformar um bitmap) ou muito pouco previsível. Para os mais previsíveis, você pode fazer o cálculo de antemão e ver quantos trabalhos podem ser executados.

Para o imprevisível você quer idealmente o sistema para iniciar alguns trabalhos que ocupam muita memória, e quando estiver pronto, você quer que o sistema comece mais empregos que ocupam menos memória. Mas você não sabe de antemão quais trabalhos vão demorar muito, o que vai demorar um pouco, e quais correm. Alguns trabalhos do ciclo de vida normal é executado com pouca memória por um longo tempo e, em seguida, balão para um tamanho muito maior mais tarde. É muito difícil dizer a diferença entre esses trabalhos e trabalhos que correm livremente.

Quando alguém me aponta para um caminho bem pensado para fazer isso de uma maneira que faça sentido para muitas aplicações, então GNU Parallel provavelmente será estendido com isso.