usage - total memory used by process linux




¿Cómo medir el uso de memoria real de una aplicación o proceso? (20)

¿Qué pasa con el time ?

No es el time incorporado de Bash sino el que puede encontrar con which time , por ejemplo /usr/bin/time

Esto es lo que cubre, en un simple ls :

$ /usr/bin/time --verbose ls
(...)
Command being timed: "ls"
User time (seconds): 0.00
System time (seconds): 0.00
Percent of CPU this job got: 0%
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): 2372
Average resident set size (kbytes): 0
Major (requiring I/O) page faults: 1
Minor (reclaiming a frame) page faults: 121
Voluntary context switches: 2
Involuntary context switches: 9
Swaps: 0
File system inputs: 256
File system outputs: 0
Socket messages sent: 0
Socket messages received: 0
Signals delivered: 0
Page size (bytes): 4096
Exit status: 0

Esta pregunta se trata here con gran detalle.

¿Cómo se mide el uso de memoria de una aplicación o proceso en Linux?

Del artículo del blog sobre la comprensión del uso de la memoria en Linux , ps no es una herramienta precisa para este propósito.

Porque ps es "incorrecto"

Dependiendo de cómo se mire, ps no informa el uso real de memoria de los procesos. Lo que realmente está haciendo es mostrar cuánta memoria real tomaría cada proceso si fuera el único proceso en ejecución . Por supuesto, una máquina Linux típica tiene varias docenas de procesos que se ejecutan en un momento dado, lo que significa que los números VSZ y RSS reportados por ps son casi definitivamente erróneos .


Además de las soluciones enumeradas en tus respuestas, puedes usar el comando de Linux "top"; Proporciona una vista dinámica en tiempo real del sistema en ejecución, proporciona el uso de la CPU y la memoria para todo el sistema junto con cada programa, en porcentaje:

top

Para filtrar por un programa pid:

top -p <PID>

para filtrar por un nombre de programa:

top | grep <PROCESS NAME>

"top" también proporciona algunos campos como:

VIRT - Imagen virtual (kb): la cantidad total de memoria virtual utilizada por la tarea

RES - Tamaño del residente (kb): la memoria física no intercambiada que una tarea ha utilizado; RES = CÓDIGO + DATOS.

DATOS - Tamaño de pila de datos (kb): la cantidad de memoria física dedicada a otro código que no sea ejecutable, también conocido como tamaño de 'conjunto residente de datos' o DRS.

SHR - Tamaño de memoria compartida (kb): la cantidad de memoria compartida utilizada por una tarea. Simplemente refleja la memoria que podría compartirse potencialmente con otros procesos.

Referencia here .


En versiones recientes de linux, use el subsistema smaps . Por ejemplo, para un proceso con un PID de 1234:

cat /proc/1234/smaps

Le dirá exactamente cuánta memoria está usando en ese momento. Más importante aún, dividirá la memoria en privada y compartida, para que pueda saber cuánta memoria está usando su instancia del programa, sin incluir la memoria compartida entre varias instancias del programa.


Es difícil decirlo con seguridad, pero aquí hay dos cosas "cercanas" que pueden ayudar.

$ ps aux 

le dará tamaño virtual (VSZ)

También puede obtener estadísticas detalladas de / proc file-system yendo a /proc/$pid/status

El más importante es el VmSize, que debería estar cerca de lo que da ps aux .

/proc/19420$ cat status
Name:   firefox
State:  S (sleeping)
Tgid:   19420
Pid:    19420
PPid:   1
TracerPid:  0
Uid:    1000    1000    1000    1000
Gid:    1000    1000    1000    1000
FDSize: 256
Groups: 4 6 20 24 25 29 30 44 46 107 109 115 124 1000 
VmPeak:   222956 kB
VmSize:   212520 kB
VmLck:         0 kB
VmHWM:    127912 kB
VmRSS:    118768 kB
VmData:   170180 kB
VmStk:       228 kB
VmExe:        28 kB
VmLib:     35424 kB
VmPTE:       184 kB
Threads:    8
SigQ:   0/16382
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000000000
SigIgn: 0000000020001000
SigCgt: 000000018000442f
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
Cpus_allowed:   03
Mems_allowed:   1
voluntary_ctxt_switches:    63422
nonvoluntary_ctxt_switches: 7171


Estoy usando htop ; Es un programa de consola muy bueno similar al Administrador de tareas de Windows.


No hay una manera fácil de calcular esto. Pero algunas personas han tratado de obtener algunas buenas respuestas:


Pruebe el comando pmap :

sudo pmap -x <process pid>

Si su código está en C o C ++, es posible que pueda usar getrusage() que le devuelve varias estadísticas sobre la memoria y el uso del tiempo de su proceso.

Sin embargo, no todas las plataformas admiten esto y devolverán 0 valores para las opciones de uso de memoria.

En su lugar, puede ver el archivo virtual creado en /proc/[pid]/statm (donde [pid] es reemplazado por su id de proceso. Puede obtenerlo de getpid() ).

Este archivo se verá como un archivo de texto con 7 enteros. Probablemente esté más interesado en los números primero (uso de memoria) y sexto (uso de memoria de datos) en este archivo.


Use smem , que es una alternativa a ps que calcula el USS y PSS por proceso. Lo que quieres es probablemente el PSS.

  • USS - Tamaño de conjunto único. Esta es la cantidad de memoria no compartida única para ese proceso (considérelo como U para la memoria única ). No incluye memoria compartida. Por lo tanto, esto no reportará la cantidad de memoria que utiliza un proceso, pero es útil cuando se quiere ignorar la memoria compartida.

  • PSS - Tamaño de conjunto proporcional. Esto es lo que quieres. Agrega la memoria única (USS), junto con una proporción de su memoria compartida dividida por la cantidad de otros procesos que comparten esa memoria. Por lo tanto, le proporcionará una representación precisa de la cantidad de memoria física real que se está utilizando por proceso, con la memoria compartida realmente representada como compartida. Piensa que la P es para la memoria física .

Cómo se compara esto con RSS según lo informado por ps y otras utilidades:

  • RSS - Tamaño del conjunto residente. Esta es la cantidad de memoria compartida más la memoria no compartida utilizada por cada proceso. Si algún proceso comparte memoria, esto reportará en exceso la cantidad de memoria realmente utilizada, porque la misma memoria compartida se contará más de una vez, apareciendo nuevamente en cada otro proceso que comparte la misma memoria. Por lo tanto, es bastante poco confiable, especialmente cuando los procesos de alta memoria tienen muchas bifurcaciones, lo cual es común en un servidor, con procesos como Apache o PHP (fastcgi / FPM).

Aviso: smem también puede (opcionalmente) generar gráficos como gráficos circulares y similares. En mi opinión, no necesitas nada de eso. Si solo desea usarlo desde la línea de comandos como podría usar ps -A v, entonces no necesita instalar la dependencia recomendada de python-matplotlib.


Valgrind es increíble si tienes tiempo para ejecutarlo. valgrind --tool=massif es la solución correcta.

Sin embargo, estoy empezando a ejecutar ejemplos más grandes, y usar valgrind ya no es práctico. ¿Hay alguna forma de indicar el uso máximo de memoria (tamaño de página en módulo y páginas compartidas) de un programa?

En un sistema UNIX real, /usr/bin/time -v funciona. En Linux, sin embargo, esto no funciona.


Valgrind puede mostrar información detallada pero ralentiza significativamente la aplicación de destino, y la mayoría de las veces cambia el comportamiento de la aplicación.
Exmap era algo que aún no sabía, pero parece que necesita un módulo del kernel para obtener la información, lo que puede ser un obstáculo.

Supongo que lo que todos quieren saber sobre WRT "uso de memoria" es lo siguiente ...
En Linux, la cantidad de memoria física que un solo proceso puede usar puede dividirse aproximadamente en las siguientes categorías.

  • Memoria anónima mapeada ma

    • .p privado
      • .d sucio == malloc / mmapped pila y pila asignada y memoria escrita
      • .c clean == malloc / mmapped pila y memoria de pila una vez asignada, escrita, luego liberada, pero no reclamada todavía
    • .s ha compartido
      • .d dirty == malloc / mmaped heap podría copiarse y escribirse entre procesos (editado)
      • .c clean == malloc / mmaped heap podría copiarse y escribirse entre procesos (editado)
  • Mn nombrada memoria asignada

    • .p privado
      • .d sucio == archivo mmapped memoria escrita privada
      • .c limpio == programa asignado / texto de biblioteca asignado privado
    • .s ha compartido
      • .d sucio == archivo mmapped memoria escrita compartida
      • .c clean == mapeado texto de la biblioteca compartido mapeado

Utilidad incluida en Android llamada showmap es bastante útil

virtual                    shared   shared   private  private
size     RSS      PSS      clean    dirty    clean    dirty    object
-------- -------- -------- -------- -------- -------- -------- ------------------------------
       4        0        0        0        0        0        0 0:00 0                  [vsyscall]
       4        4        0        4        0        0        0                         [vdso]
      88       28       28        0        0        4       24                         [stack]
      12       12       12        0        0        0       12 7909                    /lib/ld-2.11.1.so
      12        4        4        0        0        0        4 89529                   /usr/lib/locale/en_US.utf8/LC_IDENTIFICATION
      28        0        0        0        0        0        0 86661                   /usr/lib/gconv/gconv-modules.cache
       4        0        0        0        0        0        0 87660                   /usr/lib/locale/en_US.utf8/LC_MEASUREMENT
       4        0        0        0        0        0        0 89528                   /usr/lib/locale/en_US.utf8/LC_TELEPHONE
       4        0        0        0        0        0        0 89527                   /usr/lib/locale/en_US.utf8/LC_ADDRESS
       4        0        0        0        0        0        0 87717                   /usr/lib/locale/en_US.utf8/LC_NAME
       4        0        0        0        0        0        0 87873                   /usr/lib/locale/en_US.utf8/LC_PAPER
       4        0        0        0        0        0        0 13879                   /usr/lib/locale/en_US.utf8/LC_MESSAGES/SYS_LC_MESSAGES
       4        0        0        0        0        0        0 89526                   /usr/lib/locale/en_US.utf8/LC_MONETARY
       4        0        0        0        0        0        0 89525                   /usr/lib/locale/en_US.utf8/LC_TIME
       4        0        0        0        0        0        0 11378                   /usr/lib/locale/en_US.utf8/LC_NUMERIC
    1156        8        8        0        0        4        4 11372                   /usr/lib/locale/en_US.utf8/LC_COLLATE
     252        0        0        0        0        0        0 11321                   /usr/lib/locale/en_US.utf8/LC_CTYPE
     128       52        1       52        0        0        0 7909                    /lib/ld-2.11.1.so
    2316       32       11       24        0        0        8 7986                    /lib/libncurses.so.5.7
    2064        8        4        4        0        0        4 7947                    /lib/libdl-2.11.1.so
    3596      472       46      440        0        4       28 7933                    /lib/libc-2.11.1.so
    2084        4        0        4        0        0        0 7995                    /lib/libnss_compat-2.11.1.so
    2152        4        0        4        0        0        0 7993                    /lib/libnsl-2.11.1.so
    2092        0        0        0        0        0        0 8009                    /lib/libnss_nis-2.11.1.so
    2100        0        0        0        0        0        0 7999                    /lib/libnss_files-2.11.1.so
    3752     2736     2736        0        0      864     1872                         [heap]
      24       24       24        0        0        0       24 [anon]
     916      616      131      584        0        0       32                         /bin/bash
-------- -------- -------- -------- -------- -------- -------- ------------------------------
   22816     4004     3005     1116        0      876     2012 TOTAL

A continuación, la línea de comandos le dará la memoria total utilizada por los diversos procesos que se ejecutan en la máquina Linux en MB

ps -eo size,pid,user,command --sort -size | awk '{ hr=$1/1024 ; printf("%13.2f Mb ",hr) } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | awk '{total=total + $1} END {print total}'

Si el proceso no consume demasiada memoria (ya sea porque espera que esto ocurra o porque algún otro comando haya dado esta indicación inicial), y el proceso puede soportar la detención durante un corto período de tiempo, puede intentar usar el comando gcore

gcore <pid>

Verifique el tamaño del archivo principal generado para obtener una buena idea de cuánta memoria está usando un proceso en particular.

Esto no funcionará demasiado bien si el proceso utiliza cientos de megas o conciertos, ya que la generación del núcleo puede tardar varios segundos o minutos en crearse, según el rendimiento de E / S. Durante la creación del núcleo, el proceso se detiene (o se "congela") para evitar cambios en la memoria. Así que ten cuidado.

También asegúrese de que el punto de montaje donde se genera el núcleo tenga suficiente espacio en disco y que el sistema no reaccione negativamente al archivo del núcleo que se está creando en ese directorio en particular.


Edición: esto funciona al 100% solo cuando aumenta el consumo de memoria.

Si desea monitorear el uso de la memoria mediante un proceso determinado (o un grupo de nombre común de intercambio procesado, por ejemplo google-chrome, puede usar mi script bash:

while true; do ps aux | awk ‚{print $5, $11}’ | grep chrome | sort -n > /tmp/a.txt; sleep 1; diff /tmp/{b,a}.txt; mv /tmp/{a,b}.txt; done;

Esto buscará continuamente los cambios e imprimirlos.


Otro voto para valgrind aquí, pero me gustaría agregar que puede usar una herramienta como Alleyoop para ayudarlo a interpretar los resultados generados por valgrind.

Uso las dos herramientas todo el tiempo y siempre tengo un código magro, sin fugas para mostrarlo con orgullo;)


Si bien esta pregunta parece ser sobre el examen de los procesos actualmente en ejecución, quería ver el pico de memoria utilizado por una aplicación de principio a fin. Además de valgrind, puedes usar tstime , que es mucho más simple. Mide el uso de memoria "highwater" (RSS y virtual). De esta respuesta .


Te sugiero que utilices encima de ti. Puedes encontrar todo sobre esto en esta página . Es capaz de proporcionar todos los KPI necesarios para sus procesos y también puede capturar en un archivo.


Una buena prueba del uso más "real" es abrir la aplicación, luego ejecutar vmstat -sy verificar la estadística de "memoria activa". Cierre la aplicación, espere unos segundos y vmstat -svuelva a ejecutar . Sin embargo, la aplicación liberó, evidentemente, mucha memoria activa.



#!/bin/ksh
#
# Returns total memory used by process $1 in kb.
#
# See /proc/NNNN/smaps if you want to do something
# more interesting.
#

IFS=$'\n'

for line in $(</proc/$1/smaps)
do
   [[ $line =~ ^Size:\s+(\S+) ]] && ((kb += ${.sh.match[1]}))
done

print $kb




process