Pico de uso da memória de um processo linux / unix

Existe uma ferramenta que execute uma linha de comando e relate o total de pico de uso de RAM?

Estou imaginando algo análogo a / usr / bin / time

Aqui está uma linha que não requer scripts ou utilitários externos e não requer que você inicie o processo por outro programa como o Valgrind ou o time, para que você possa usá-lo para qualquer processo que já esteja em execução:

grep VmPeak /proc/$PID/status

(substitua $PIDpelo PID do processo em que você está interessado)

[ Edit : Funciona no Ubuntu 14.04: /usr/bin/time -v command Certifique-se de usar o caminho completo.]

Parece /usr/bin/timeque você fornece essas informações, se você passar -v(isso é no Ubuntu 8.10). Veja, por exemplo, Maximum resident set sizeabaixo:

$ / usr / bin / time -v ls /
....
        Comando sendo cronometrado: "ls /"
        Tempo do usuário (segundos): 0.00
        Tempo do sistema (segundos): 0,01
        Porcentagem de CPU que este trabalho obteve: 250%
        Tempo decorrido (relógio de parede) (h: mm: ss ou m: ss): 0: 00.00
        Tamanho médio do texto compartilhado (kbytes): 0
        Tamanho médio dos dados não compartilhados (kbytes): 0
        Tamanho médio da pilha (kbytes): 0
        Tamanho total médio (kbytes): 0
        Tamanho máximo do conjunto de residentes (kbytes): 0
        Tamanho médio do conjunto de residentes (kbytes): 0
        Falhas na página principal (que requer E / S): 0
        Falhas de página secundárias (recuperando um quadro): 315
        Mudanças de contexto voluntárias: 2
        Opções de contexto involuntárias: 0
        Swaps: 0
        Entradas do sistema de arquivos: 0
        Saídas do sistema de arquivos: 0
        Mensagens de soquete enviadas: 0
        Mensagens de soquete recebidas: 0
        Sinais entregues: 0
        Tamanho da página (bytes): 4096
        Status de saída: 0

(Esta é uma pergunta antiga já respondida .. mas apenas para constar :)

Fui inspirado pelo script de Yang e criei esta pequena ferramenta, chamada memusg . Simplesmente aumentei a taxa de amostragem para 0,1 para lidar com processos de vida muito curtos. Em vez de monitorar um único processo, eu o fiz medir a soma rss do grupo de processos. (Sim, eu escrevo muitos programas separados que funcionam juntos) Atualmente, ele funciona no Mac OS X e Linux. O uso tinha que ser semelhante ao de time:

memusg ls -alR /> / dev / null

Ele mostra apenas o pico no momento, mas estou interessado em pequenas extensões para gravar outras estatísticas (aproximadas).

É bom ter uma ferramenta tão simples para dar uma olhada antes de iniciar qualquer perfil sério.

Linha única Valgrind:

valgrind --tool=massif --pages-as-heap=yes --massif-out-file=massif.out ./test.sh; grep mem_heap_B massif.out | sed -e 's/mem_heap_B=\(.*\)/\1/' | sort -g | tail -n 1

Observe o uso de --pages-as-heap para medir toda a memória em um processo. Mais informações aqui: http://valgrind.org/docs/manual/ms-manual.html

No Linux:

Use /usr/bin/time -v <program> <args>e procure " Tamanho máximo do conjunto de residentes ".

(Não deve ser confundida com o Bash timecomando interno! Portanto, use o caminho completo , /usr/bin/time)

Por exemplo:

> /usr/bin/time -v ./myapp
        User time (seconds): 0.00
        . . .
        Maximum resident set size (kbytes): 2792
        . . .

No BSD, MacOS:

Use /usr/bin/time -l <program> <args>, procurando " tamanho máximo do conjunto de residentes ":

>/usr/bin/time -l ./myapp
        0.01 real         0.00 user         0.00 sys
      1440  maximum resident set size
      . . .

Talvez o (gnu) time (1) já faça o que você deseja. Por exemplo:

$ /usr/bin/time -f "%P %M" command
43% 821248

Mas outras ferramentas de criação de perfil podem fornecer resultados mais precisos, dependendo do que você está procurando.

/ usr / bin / time talvez faça o que você quer, na verdade. Algo como.

 / usr / bin / time --format = '(% Xtext +% Ddata% Mmax)'

Veja o tempo (1) para detalhes ...

No MacOS Sierra, use:

/usr/bin/time -l commandToMeasure

Você pode usar greppara pegar o que quiser, talvez.

Se o processo for executado por pelo menos alguns segundos, você poderá usar o seguinte script bash, que executará a linha de comando especificada e imprimirá o stderr do RSS de pico (substitua rssqualquer outro atributo no qual você esteja interessado). É um pouco leve e funciona para mim com o psincluído no Ubuntu 9.04 (o que não posso dizer time).

#!/usr/bin/env bash
"$@" & # Run the given command line in the background.
pid=$! peak=0
while true; do
  sleep 1
  sample="$(ps -o rss= $pid 2> /dev/null)" || break
  let peak='sample > peak ? sample : peak'
done
echo "Peak: $peak" 1>&2

time -f '%M' <run_program>

Bem, se você realmente deseja mostrar o pico de memória e algumas estatísticas mais detalhadas, recomendo usar um criador de perfil como o valgrind . Um bom front-end do valgrind é o alleyoop .

Você pode usar uma ferramenta como Valgrind para fazer isso.

Aqui está (com base nas outras respostas) um script muito simples que assiste a um processo já em execução. Você acabou de executá-lo com o pid do processo que deseja assistir como argumento:

#!/usr/bin/env bash

pid=$1

while ps $pid >/dev/null
do
    ps -o vsz= ${pid}
    sleep 1
done | sort -n | tail -n1

Exemplo de uso:

max_mem_usage.sh 23423

Use o Maciço: http://valgrind.org/docs/manual/ms-manual.html

Heaptrack é uma ferramenta do KDE que possui uma interface gráfica e de texto. Acho mais adequado do que o valgrind entender o uso da memória de um processo, pois fornece mais detalhes e gráficos. Também é mais rápido porque faz menos verificação desse valor. E fornece o pico de uso da memória.

De qualquer forma, rastrear rss e vss é enganoso porque as páginas podem ser compartilhadas, é por isso que memusg. O que você realmente deve fazer é acompanhar a soma de Pssin /proc/[pid]/smapsou use pmap. O monitor do sistema GNOME costumava fazer isso, mas era muito caro.

Re-inventando a roda, com script bash feito à mão. Rápido e limpo.

Meu caso de uso: eu queria monitorar uma máquina Linux com menos RAM e tirar uma foto instantânea do uso por contêiner quando executado sob uso pesado.

#!/usr/bin/env bash

threshold=$1

echo "$(date '+%Y-%m-%d %H:%M:%S'): Running free memory monitor with threshold $threshold%.."

while(true)
    freePercent=`free -m | grep Mem: | awk '{print ($7/$2)*100}'`    
  do

  if (( $(awk 'BEGIN {print ("'$freePercent'" < "'$threshold'")}') ))
  then
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Free memory $freePercent% is less than $threshold%"
       free -m
       docker stats --no-stream
       sleep 60  
       echo ""  
  else
       echo "$(date '+%Y-%m-%d %H:%M:%S'): Sufficient free memory available: $freePercent%"
  fi
  sleep 30

done

Saída de amostra:

2017-10-12 13:29:33: Executando monitor de memória livre com limite de 30% ..

2017-10-12 13:29:33: Memória livre suficiente disponível: 69.4567%

2017-10-12 13:30:03: Memória livre suficiente disponível: 69.4567%

2017-10-12 16:47:02: Memória livre 18.9387% é inferior a 30%

sua Saída de Comando Customizada

No macOS, você pode usar o DTrace. O aplicativo "Instruments" é uma ótima interface gráfica para isso, vem com o XCode afaik.

'htop' é o melhor comando para ver qual processo está usando quanta RAM .....

para obter mais detalhes http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html

Certifique-se de responder à pergunta. Forneça detalhes e compartilhe sua pesquisa!

Desculpe, sou a primeira vez aqui e só posso fazer perguntas ...

Usado sugerido:

valgrind --tool=massif --pages-as-heap=yes --massif-out-file=massif.out ./test.sh; grep mem_heap_B massif.out | sed -e 's/mem_heap_B=\(.*\)/\1/' | sort -g | tail -n 1

então:

grep mem_heap_B massif.out
...
mem_heap_B=1150976
mem_heap_B=1150976
...

isso é muito diferente do que o topcomando mostra em um momento semelhante:

14673 gu27mox   20   0 3280404 468380  19176 R 100.0  2.9   6:08.84 pwanew_3pic_com

o que são unidades medidas do Valgrind?

O /usr/bin/time -v ./test.shnunca respondeu - você deve alimentar diretamente o executável para /usr/bin/timegostar:

/usr/bin/time -v  pwanew_3pic_compass_2008florian3_dfunc.static  card_0.100-0.141_31212_resubmit1.dat_1.140_1.180   1.140 1.180 31212


    Command being timed: "pwanew_3pic_compass_2008florian3_dfunc.static card_0.100-0.141_31212_resubmit1.dat_1.140_1.180 1.140 1.180 31212"

    User time (seconds): 1468.44
    System time (seconds): 7.37
    Percent of CPU this job got: 99%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 24:37.14
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 574844
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 74
    Minor (reclaiming a frame) page faults: 468880
    Voluntary context switches: 1190
    Involuntary context switches: 20534
    Swaps: 0
    File system inputs: 81128
    File system outputs: 1264
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 0