Uso máximo de memoria de un proceso Linux / Unix

¿Existe una herramienta que ejecute una línea de comandos e informe el uso total de RAM máximo?

Me estoy imaginando algo análogo a / usr / bin / time

Aquí hay una línea que no requiere scripts o utilidades externas y no requiere que inicie el proceso a través de otro programa como Valgrind o tiempo, por lo que puede usarlo para cualquier proceso que ya se esté ejecutando:

grep VmPeak /proc/$PID/status

(reemplazar $PIDcon el PID del proceso que le interesa)

[ Editar : funciona en Ubuntu 14.04: /usr/bin/time -v command asegúrese de utilizar la ruta completa.]

Parece /usr/bin/timeque te da esa información, si la pasas -v(esto está en Ubuntu 8.10). Ver, por ejemplo, a Maximum resident set sizecontinuación:

$ / usr / bin / time -v ls /
....
        Comando cronometrado: "ls /"
        Tiempo de usuario (segundos): 0.00
        Tiempo del sistema (segundos): 0.01
        Porcentaje de CPU que obtuvo este trabajo: 250%
        Tiempo transcurrido (reloj de pared) (h: mm: ss o m: ss): 0: 00.00
        Tamaño promedio de texto compartido (kbytes): 0
        Tamaño promedio de datos no compartidos (kbytes): 0
        Tamaño de pila promedio (kbytes): 0
        Tamaño total promedio (kbytes): 0
        Tamaño máximo del conjunto residente (kbytes): 0
        Tamaño promedio del conjunto residente (kbytes): 0
        Fallos de página principales (que requieren E / S): 0
        Fallos de página menores (reclamar un marco): 315
        Cambios de contexto voluntarios: 2
        Cambios de contexto involuntarios: 0
        Swaps: 0
        Entradas del sistema de archivos: 0
        Salidas del sistema de archivos: 0
        Mensajes de socket enviados: 0
        Mensajes de socket recibidos: 0
        Señales entregadas: 0
        Tamaño de página (bytes): 4096
        Estado de salida: 0

(Esta es una pregunta antigua ya respondida ... pero solo para el registro :)

Me inspiró el guión de Yang y se me ocurrió esta pequeña herramienta, llamada memusg . Simplemente aumenté la frecuencia de muestreo a 0.1 para manejar procesos de vida muy cortos. En lugar de monitorear un solo proceso, lo hice medir la primera suma del grupo de procesos. (Sí, escribo muchos programas separados que funcionan juntos) Actualmente funciona en Mac OS X y Linux. El uso tenía que ser similar al de time:

memusg ls -alR /> / dev / null

Solo muestra el pico por el momento, pero estoy interesado en pequeñas extensiones para registrar otras estadísticas (aproximadas).

Es bueno tener una herramienta tan simple para echar un vistazo antes de comenzar cualquier perfil serio.

Valgrind one-liner:

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

Tenga en cuenta el uso de --pages-as-heap para medir toda la memoria en un proceso. Más información aquí: http://valgrind.org/docs/manual/ms-manual.html

En Linux:

Use /usr/bin/time -v <program> <args>y busque " Tamaño máximo de conjunto residente ".

(No debe confundirse con el Golpe timecomando integrado! Así que utilice la ruta completa , /usr/bin/time)

Por ejemplo:

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

En BSD, MacOS:

Uso /usr/bin/time -l <program> <args>, buscando " tamaño máximo de conjunto residente ":

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

Quizás (gnu) el tiempo (1) ya hace lo que quieres. Por ejemplo:

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

Pero otras herramientas de creación de perfiles pueden proporcionar resultados más precisos según lo que esté buscando.

/ usr / bin / time tal vez hace lo que quieres, en realidad. Algo como.

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

Vea el tiempo (1) para más detalles ...

En MacOS Sierra use:

/usr/bin/time -l commandToMeasure

Puede usar greppara tomar lo que quiera, tal vez.

Si el proceso se ejecuta durante al menos un par de segundos, puede usar el siguiente script bash, que ejecutará la línea de comando dada y luego imprimirá para stderr el pico RSS (sustituya rsscualquier otro atributo que le interese). Es algo ligero y funciona para mí con el psincluido en Ubuntu 9.04 (que no puedo decir 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>

Bueno, si realmente desea mostrar el pico de memoria y algunas estadísticas más detalladas, le recomiendo usar un generador de perfiles como valgrind . Un buen front-end valgrind es alleyoop .

Puede usar una herramienta como Valgrind para hacer esto.

Aquí hay (basado en las otras respuestas) un script muy simple que observa un proceso que ya se está ejecutando. Simplemente lo ejecuta con el pid del proceso que desea ver 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

Ejemplo de uso:

max_mem_usage.sh 23423

Use Massif: http://valgrind.org/docs/manual/ms-manual.html

Heaptrack es una herramienta de KDE que tiene una interfaz gráfica de usuario y una interfaz de texto. Me parece más adecuado que valgrind comprender el uso de memoria de un proceso porque proporciona más detalles y gráficos de llamas. También es más rápido porque controla menos ese valor. Y te da el uso máximo de memoria.

De todos modos, el seguimiento de rss y vss es engañoso porque las páginas podrían compartirse, por eso memusg. Lo que realmente debe hacer es realizar un seguimiento de la suma de Pssin /proc/[pid]/smapso use pmap. El monitor de sistema GNOME solía hacerlo, pero era demasiado costoso.

Reinventar la rueda, con guión de bash hecho a mano. Rápido y limpio.

Mi caso de uso: quería monitorear una máquina Linux que tiene menos RAM y quería tomar una instantánea del uso por contenedor cuando se ejecuta bajo un uso intensivo.

#!/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

Salida de muestra:

2017-10-12 13:29:33: Ejecución de monitor de memoria libre con umbral 30%.

2017-10-12 13:29:33: Suficiente memoria libre disponible: 69.4567%

2017-10-12 13:30:03: Suficiente memoria libre disponible: 69.4567%

2017-10-12 16:47:02: memoria libre 18.9387% es inferior al 30%

su salida de comando personalizado

En macOS, puede usar DTrace en su lugar. La aplicación "Instrumentos" es una buena GUI para eso, viene con XCode afaik.

'htop' es el mejor comando para ver qué proceso está usando cuánta RAM .....

para más detalles http://manpages.ubuntu.com/manpages/precise/man1/htop.1.html

Asegúrate de responder la pregunta. ¡Proporcione detalles y comparta su investigación!

Lo siento, estoy aquí por primera vez y solo puedo hacer preguntas ...

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

entonces:

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

Esto es muy diferente de lo que topmuestra el comando en un momento similar:

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

¿Cuáles son las unidades medidas de Valgrind?

La /usr/bin/time -v ./test.shcontestado a - debe alimentar directamente ejecutable /usr/bin/timecomo:

/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