uso - ver procesos que consumen mas memoria linux

Uso máximo de memoria de un proceso linux/unix

Question

¿Existe alguna herramienta que ejecute una línea de comandos e informe la cantidad total de RAM utilizada?

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

Answer 1

Por favor, asegúrese de responder a la pregunta. ¡Proporciona detalles y comparte tu investigación!

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

Utilizado 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 | cola -n 1

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

esto es muy diferente de lo que muestra el comando "top" en un momento similar:

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

¿Qué son las unidades medidas de valgrind?

los

/ usr / bin / time -v ./test.sh

nunca contestado: debe enviar directamente el archivo ejecutable a / usr / bin / time como:

/ 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

Answer 2

''htop'' es el mejor comando para ver qué proceso usa la cantidad de RAM .....

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

Answer 3

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

Me inspiré en 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 mucho más cortos. En lugar de monitorear un solo proceso, hice que midiera la suma rss 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 del time :

memusg ls -alR / >/dev/null

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

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

Answer 4

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

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

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

Answer 5

Aquí está (basado en las otras respuestas) un script muy simple que observa un proceso que ya se está ejecutando. Simplemente ejecútelo 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

Answer 6

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

Answer 7

En el uso de MacOS Sierra:

/usr/bin/time -l commandToMeasure

Puedes usar grep para tomar lo que quieras tal vez.

Answer 8

En macOS, puedes usar DTrace en su lugar. La aplicación "Instruments" es una buena interfaz gráfica de usuario para eso, viene con XCode afaik.

Answer 9

Puedes usar una herramienta como Valgrind para hacer esto.

Answer 10

Reinventar la rueda, con un 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 memoria 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: Ejecutando el monitor de memoria libre con un umbral del 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 menos del 30%

su salida de comando personalizado

Answer 11

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

Answer 12

Tal vez (gnu) el time(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 ofrecer resultados más precisos en función de lo que esté buscando.

Answer 13

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

Answer 14

Valgrind de una sola línea:

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

Answer 15

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

Parece que /usr/bin/time te da esa información, si pasas -v (esto es en Ubuntu 8.10). Ver, por ejemplo, Maximum resident set size continuación:

$ /usr/bin/time -v ls / .... Command being timed: "ls /" User time (seconds): 0.00 System time (seconds): 0.01 Percent of CPU this job got: 250% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.00 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): 0 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 0 Minor (reclaiming a frame) page faults: 315 Voluntary context switches: 2 Involuntary context switches: 0 Swaps: 0 File system inputs: 0 File system outputs: 0 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0

Answer 16

Heaptrack es una herramienta de KDE que tiene una interfaz gráfica y una interfaz de texto. Me parece más adecuado que valgrind comprender el uso de la memoria de un proceso porque proporciona más detalles y detalles. También es más rápido porque comprueba menos que valgrind. 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 se pueden compartir, por eso es memusg . Lo que realmente debe hacer es rastrear la suma de Pss en /proc/[pid]/smaps o usar pmap . El monitor del sistema GNOME solía hacerlo, pero era demasiado caro.

Answer 17

En Linux:

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

(¡No debe confundirse con el comando incorporado de Bash time ! 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:

Use /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
      . . .

Answer 18

time -f ''%M'' <run_program>